]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
src/common/wxchar.cpps/wxConvLocal/wxConvLibs/g as otherwise we may fail to convert...
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260
2261
2262 // Make a tuple and put the values in it
2263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2958 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2959 PyObject* pyList = NULL;
2960 wxArrayVideoModes arr = self->GetModes(mode);
2961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2962 pyList = PyList_New(0);
2963 for (int i=0; i < arr.GetCount(); i++) {
2964 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2965 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2966 PyList_Append(pyList, pyObj);
2967 Py_DECREF(pyObj);
2968 }
2969 wxPyEndBlockThreads(blocked);
2970 return pyList;
2971 }
2972
2973 #include <wx/stdpaths.h>
2974
2975 static wxStandardPaths *StandardPaths_Get(){
2976 return (wxStandardPaths*) &wxStandardPaths::Get();
2977 }
2978 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2979 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2980 #ifdef __cplusplus
2981 extern "C" {
2982 #endif
2983 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxSystemColour arg1 ;
2986 wxColour result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "index", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2993 {
2994 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 }
2997 {
2998 if (!wxPyCheckForApp()) SWIG_fail;
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 wxColour * resultptr;
3007 resultptr = new wxColour((wxColour &)(result));
3008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3009 }
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemFont arg1 ;
3019 wxFont result;
3020 PyObject * obj0 = 0 ;
3021 char *kwnames[] = {
3022 (char *) "index", NULL
3023 };
3024
3025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3026 {
3027 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3028 if (SWIG_arg_fail(1)) SWIG_fail;
3029 }
3030 {
3031 if (!wxPyCheckForApp()) SWIG_fail;
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 wxFont * resultptr;
3040 resultptr = new wxFont((wxFont &)(result));
3041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3042 }
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3050 PyObject *resultobj;
3051 wxSystemMetric arg1 ;
3052 wxWindow *arg2 = (wxWindow *) NULL ;
3053 int result;
3054 PyObject * obj0 = 0 ;
3055 PyObject * obj1 = 0 ;
3056 char *kwnames[] = {
3057 (char *) "index",(char *) "win", NULL
3058 };
3059
3060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3061 {
3062 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3063 if (SWIG_arg_fail(1)) SWIG_fail;
3064 }
3065 if (obj1) {
3066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3067 if (SWIG_arg_fail(2)) SWIG_fail;
3068 }
3069 {
3070 if (!wxPyCheckForApp()) SWIG_fail;
3071 PyThreadState* __tstate = wxPyBeginAllowThreads();
3072 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3073
3074 wxPyEndAllowThreads(__tstate);
3075 if (PyErr_Occurred()) SWIG_fail;
3076 }
3077 {
3078 resultobj = SWIG_From_int((int)(result));
3079 }
3080 return resultobj;
3081 fail:
3082 return NULL;
3083 }
3084
3085
3086 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3087 PyObject *resultobj;
3088 wxSystemFeature arg1 ;
3089 bool result;
3090 PyObject * obj0 = 0 ;
3091 char *kwnames[] = {
3092 (char *) "index", NULL
3093 };
3094
3095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3096 {
3097 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3098 if (SWIG_arg_fail(1)) SWIG_fail;
3099 }
3100 {
3101 if (!wxPyCheckForApp()) SWIG_fail;
3102 PyThreadState* __tstate = wxPyBeginAllowThreads();
3103 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3104
3105 wxPyEndAllowThreads(__tstate);
3106 if (PyErr_Occurred()) SWIG_fail;
3107 }
3108 {
3109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3110 }
3111 return resultobj;
3112 fail:
3113 return NULL;
3114 }
3115
3116
3117 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3118 PyObject *resultobj;
3119 wxSystemScreenType result;
3120 char *kwnames[] = {
3121 NULL
3122 };
3123
3124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3125 {
3126 if (!wxPyCheckForApp()) SWIG_fail;
3127 PyThreadState* __tstate = wxPyBeginAllowThreads();
3128 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3129
3130 wxPyEndAllowThreads(__tstate);
3131 if (PyErr_Occurred()) SWIG_fail;
3132 }
3133 resultobj = SWIG_From_int((result));
3134 return resultobj;
3135 fail:
3136 return NULL;
3137 }
3138
3139
3140 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3141 PyObject *resultobj;
3142 wxSystemScreenType arg1 ;
3143 PyObject * obj0 = 0 ;
3144 char *kwnames[] = {
3145 (char *) "screen", NULL
3146 };
3147
3148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3149 {
3150 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3151 if (SWIG_arg_fail(1)) SWIG_fail;
3152 }
3153 {
3154 if (!wxPyCheckForApp()) SWIG_fail;
3155 PyThreadState* __tstate = wxPyBeginAllowThreads();
3156 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3157
3158 wxPyEndAllowThreads(__tstate);
3159 if (PyErr_Occurred()) SWIG_fail;
3160 }
3161 Py_INCREF(Py_None); resultobj = Py_None;
3162 return resultobj;
3163 fail:
3164 return NULL;
3165 }
3166
3167
3168 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3169 PyObject *obj;
3170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3171 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3172 Py_INCREF(obj);
3173 return Py_BuildValue((char *)"");
3174 }
3175 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3176 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3177 return 1;
3178 }
3179
3180
3181 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3182 PyObject *pyobj;
3183
3184 {
3185 #if wxUSE_UNICODE
3186 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3187 #else
3188 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3189 #endif
3190 }
3191 return pyobj;
3192 }
3193
3194
3195 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3196 PyObject *resultobj;
3197 wxSystemOptions *result;
3198 char *kwnames[] = {
3199 NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3203 {
3204 PyThreadState* __tstate = wxPyBeginAllowThreads();
3205 result = (wxSystemOptions *)new wxSystemOptions();
3206
3207 wxPyEndAllowThreads(__tstate);
3208 if (PyErr_Occurred()) SWIG_fail;
3209 }
3210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3211 return resultobj;
3212 fail:
3213 return NULL;
3214 }
3215
3216
3217 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3218 PyObject *resultobj;
3219 wxString *arg1 = 0 ;
3220 wxString *arg2 = 0 ;
3221 bool temp1 = false ;
3222 bool temp2 = false ;
3223 PyObject * obj0 = 0 ;
3224 PyObject * obj1 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "name",(char *) "value", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3230 {
3231 arg1 = wxString_in_helper(obj0);
3232 if (arg1 == NULL) SWIG_fail;
3233 temp1 = true;
3234 }
3235 {
3236 arg2 = wxString_in_helper(obj1);
3237 if (arg2 == NULL) SWIG_fail;
3238 temp2 = true;
3239 }
3240 {
3241 PyThreadState* __tstate = wxPyBeginAllowThreads();
3242 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3243
3244 wxPyEndAllowThreads(__tstate);
3245 if (PyErr_Occurred()) SWIG_fail;
3246 }
3247 Py_INCREF(Py_None); resultobj = Py_None;
3248 {
3249 if (temp1)
3250 delete arg1;
3251 }
3252 {
3253 if (temp2)
3254 delete arg2;
3255 }
3256 return resultobj;
3257 fail:
3258 {
3259 if (temp1)
3260 delete arg1;
3261 }
3262 {
3263 if (temp2)
3264 delete arg2;
3265 }
3266 return NULL;
3267 }
3268
3269
3270 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3271 PyObject *resultobj;
3272 wxString *arg1 = 0 ;
3273 int arg2 ;
3274 bool temp1 = false ;
3275 PyObject * obj0 = 0 ;
3276 PyObject * obj1 = 0 ;
3277 char *kwnames[] = {
3278 (char *) "name",(char *) "value", NULL
3279 };
3280
3281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3282 {
3283 arg1 = wxString_in_helper(obj0);
3284 if (arg1 == NULL) SWIG_fail;
3285 temp1 = true;
3286 }
3287 {
3288 arg2 = (int)(SWIG_As_int(obj1));
3289 if (SWIG_arg_fail(2)) SWIG_fail;
3290 }
3291 {
3292 PyThreadState* __tstate = wxPyBeginAllowThreads();
3293 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3294
3295 wxPyEndAllowThreads(__tstate);
3296 if (PyErr_Occurred()) SWIG_fail;
3297 }
3298 Py_INCREF(Py_None); resultobj = Py_None;
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return resultobj;
3304 fail:
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxString *arg1 = 0 ;
3316 wxString result;
3317 bool temp1 = false ;
3318 PyObject * obj0 = 0 ;
3319 char *kwnames[] = {
3320 (char *) "name", NULL
3321 };
3322
3323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3324 {
3325 arg1 = wxString_in_helper(obj0);
3326 if (arg1 == NULL) SWIG_fail;
3327 temp1 = true;
3328 }
3329 {
3330 PyThreadState* __tstate = wxPyBeginAllowThreads();
3331 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3332
3333 wxPyEndAllowThreads(__tstate);
3334 if (PyErr_Occurred()) SWIG_fail;
3335 }
3336 {
3337 #if wxUSE_UNICODE
3338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3339 #else
3340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3341 #endif
3342 }
3343 {
3344 if (temp1)
3345 delete arg1;
3346 }
3347 return resultobj;
3348 fail:
3349 {
3350 if (temp1)
3351 delete arg1;
3352 }
3353 return NULL;
3354 }
3355
3356
3357 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3358 PyObject *resultobj;
3359 wxString *arg1 = 0 ;
3360 int result;
3361 bool temp1 = false ;
3362 PyObject * obj0 = 0 ;
3363 char *kwnames[] = {
3364 (char *) "name", NULL
3365 };
3366
3367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3368 {
3369 arg1 = wxString_in_helper(obj0);
3370 if (arg1 == NULL) SWIG_fail;
3371 temp1 = true;
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 {
3384 if (temp1)
3385 delete arg1;
3386 }
3387 return resultobj;
3388 fail:
3389 {
3390 if (temp1)
3391 delete arg1;
3392 }
3393 return NULL;
3394 }
3395
3396
3397 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3398 PyObject *resultobj;
3399 wxString *arg1 = 0 ;
3400 bool result;
3401 bool temp1 = false ;
3402 PyObject * obj0 = 0 ;
3403 char *kwnames[] = {
3404 (char *) "name", NULL
3405 };
3406
3407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3408 {
3409 arg1 = wxString_in_helper(obj0);
3410 if (arg1 == NULL) SWIG_fail;
3411 temp1 = true;
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 {
3421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3422 }
3423 {
3424 if (temp1)
3425 delete arg1;
3426 }
3427 return resultobj;
3428 fail:
3429 {
3430 if (temp1)
3431 delete arg1;
3432 }
3433 return NULL;
3434 }
3435
3436
3437 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3438 PyObject *obj;
3439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3440 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3441 Py_INCREF(obj);
3442 return Py_BuildValue((char *)"");
3443 }
3444 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3445 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3446 return 1;
3447 }
3448
3449
3450 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3451 PyObject *pyobj;
3452
3453 {
3454 #if wxUSE_UNICODE
3455 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3456 #else
3457 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3458 #endif
3459 }
3460 return pyobj;
3461 }
3462
3463
3464 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3465 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3466 return 1;
3467 }
3468
3469
3470 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3471 PyObject *pyobj;
3472
3473 {
3474 #if wxUSE_UNICODE
3475 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3476 #else
3477 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3478 #endif
3479 }
3480 return pyobj;
3481 }
3482
3483
3484 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3485 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3486 return 1;
3487 }
3488
3489
3490 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3491 PyObject *pyobj;
3492
3493 {
3494 #if wxUSE_UNICODE
3495 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3496 #else
3497 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3498 #endif
3499 }
3500 return pyobj;
3501 }
3502
3503
3504 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3505 PyObject *resultobj;
3506 long result;
3507 char *kwnames[] = {
3508 NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 result = (long)wxNewId();
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 {
3520 resultobj = SWIG_From_long((long)(result));
3521 }
3522 return resultobj;
3523 fail:
3524 return NULL;
3525 }
3526
3527
3528 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3529 PyObject *resultobj;
3530 long arg1 ;
3531 PyObject * obj0 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "id", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3537 {
3538 arg1 = (long)(SWIG_As_long(obj0));
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 }
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 wxRegisterId(arg1);
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 Py_INCREF(Py_None); resultobj = Py_None;
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 long result;
3558 char *kwnames[] = {
3559 NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3563 {
3564 PyThreadState* __tstate = wxPyBeginAllowThreads();
3565 result = (long)wxGetCurrentId();
3566
3567 wxPyEndAllowThreads(__tstate);
3568 if (PyErr_Occurred()) SWIG_fail;
3569 }
3570 {
3571 resultobj = SWIG_From_long((long)(result));
3572 }
3573 return resultobj;
3574 fail:
3575 return NULL;
3576 }
3577
3578
3579 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3580 PyObject *resultobj;
3581 int arg1 ;
3582 bool result;
3583 PyObject * obj0 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "id", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3589 {
3590 arg1 = (int)(SWIG_As_int(obj0));
3591 if (SWIG_arg_fail(1)) SWIG_fail;
3592 }
3593 {
3594 PyThreadState* __tstate = wxPyBeginAllowThreads();
3595 result = (bool)wxIsStockID(arg1);
3596
3597 wxPyEndAllowThreads(__tstate);
3598 if (PyErr_Occurred()) SWIG_fail;
3599 }
3600 {
3601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3602 }
3603 return resultobj;
3604 fail:
3605 return NULL;
3606 }
3607
3608
3609 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj;
3611 int arg1 ;
3612 wxString *arg2 = 0 ;
3613 bool result;
3614 bool temp2 = false ;
3615 PyObject * obj0 = 0 ;
3616 PyObject * obj1 = 0 ;
3617 char *kwnames[] = {
3618 (char *) "id",(char *) "label", NULL
3619 };
3620
3621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3622 {
3623 arg1 = (int)(SWIG_As_int(obj0));
3624 if (SWIG_arg_fail(1)) SWIG_fail;
3625 }
3626 {
3627 arg2 = wxString_in_helper(obj1);
3628 if (arg2 == NULL) SWIG_fail;
3629 temp2 = true;
3630 }
3631 {
3632 PyThreadState* __tstate = wxPyBeginAllowThreads();
3633 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3634
3635 wxPyEndAllowThreads(__tstate);
3636 if (PyErr_Occurred()) SWIG_fail;
3637 }
3638 {
3639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3640 }
3641 {
3642 if (temp2)
3643 delete arg2;
3644 }
3645 return resultobj;
3646 fail:
3647 {
3648 if (temp2)
3649 delete arg2;
3650 }
3651 return NULL;
3652 }
3653
3654
3655 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3656 PyObject *resultobj;
3657 int arg1 ;
3658 bool arg2 = (bool) true ;
3659 wxString arg3 = (wxString) wxPyEmptyString ;
3660 wxString result;
3661 PyObject * obj0 = 0 ;
3662 PyObject * obj1 = 0 ;
3663 PyObject * obj2 = 0 ;
3664 char *kwnames[] = {
3665 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3666 };
3667
3668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3669 {
3670 arg1 = (int)(SWIG_As_int(obj0));
3671 if (SWIG_arg_fail(1)) SWIG_fail;
3672 }
3673 if (obj1) {
3674 {
3675 arg2 = (bool)(SWIG_As_bool(obj1));
3676 if (SWIG_arg_fail(2)) SWIG_fail;
3677 }
3678 }
3679 if (obj2) {
3680 {
3681 wxString* sptr = wxString_in_helper(obj2);
3682 if (sptr == NULL) SWIG_fail;
3683 arg3 = *sptr;
3684 delete sptr;
3685 }
3686 }
3687 {
3688 PyThreadState* __tstate = wxPyBeginAllowThreads();
3689 result = wxGetStockLabel(arg1,arg2,arg3);
3690
3691 wxPyEndAllowThreads(__tstate);
3692 if (PyErr_Occurred()) SWIG_fail;
3693 }
3694 {
3695 #if wxUSE_UNICODE
3696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3697 #else
3698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3699 #endif
3700 }
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 char *kwnames[] = {
3710 NULL
3711 };
3712
3713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3714 {
3715 if (!wxPyCheckForApp()) SWIG_fail;
3716 PyThreadState* __tstate = wxPyBeginAllowThreads();
3717 wxBell();
3718
3719 wxPyEndAllowThreads(__tstate);
3720 if (PyErr_Occurred()) SWIG_fail;
3721 }
3722 Py_INCREF(Py_None); resultobj = Py_None;
3723 return resultobj;
3724 fail:
3725 return NULL;
3726 }
3727
3728
3729 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3730 PyObject *resultobj;
3731 char *kwnames[] = {
3732 NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3736 {
3737 if (!wxPyCheckForApp()) SWIG_fail;
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 wxEndBusyCursor();
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 bool arg1 = (bool) true ;
3754 long result;
3755 PyObject * obj0 = 0 ;
3756 char *kwnames[] = {
3757 (char *) "resetTimer", NULL
3758 };
3759
3760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3761 if (obj0) {
3762 {
3763 arg1 = (bool)(SWIG_As_bool(obj0));
3764 if (SWIG_arg_fail(1)) SWIG_fail;
3765 }
3766 }
3767 {
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 result = (long)wxGetElapsedTime(arg1);
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 {
3775 resultobj = SWIG_From_long((long)(result));
3776 }
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj;
3785 int *arg1 = (int *) 0 ;
3786 int *arg2 = (int *) 0 ;
3787 int temp1 ;
3788 int res1 = 0 ;
3789 int temp2 ;
3790 int res2 = 0 ;
3791 char *kwnames[] = {
3792 NULL
3793 };
3794
3795 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3796 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3798 {
3799 if (!wxPyCheckForApp()) SWIG_fail;
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 wxGetMousePosition(arg1,arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3808 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3809 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3810 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 bool result;
3820 char *kwnames[] = {
3821 NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (bool)wxIsBusy();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxString result;
3844 char *kwnames[] = {
3845 NULL
3846 };
3847
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3849 {
3850 PyThreadState* __tstate = wxPyBeginAllowThreads();
3851 result = wxNow();
3852
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 {
3857 #if wxUSE_UNICODE
3858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3859 #else
3860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3861 #endif
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxString const &arg1_defvalue = wxPyEmptyString ;
3872 wxString *arg1 = (wxString *) &arg1_defvalue ;
3873 bool result;
3874 bool temp1 = false ;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "command", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3881 if (obj0) {
3882 {
3883 arg1 = wxString_in_helper(obj0);
3884 if (arg1 == NULL) SWIG_fail;
3885 temp1 = true;
3886 }
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 result = (bool)wxShell((wxString const &)*arg1);
3891
3892 wxPyEndAllowThreads(__tstate);
3893 if (PyErr_Occurred()) SWIG_fail;
3894 }
3895 {
3896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3897 }
3898 {
3899 if (temp1)
3900 delete arg1;
3901 }
3902 return resultobj;
3903 fail:
3904 {
3905 if (temp1)
3906 delete arg1;
3907 }
3908 return NULL;
3909 }
3910
3911
3912 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3913 PyObject *resultobj;
3914 char *kwnames[] = {
3915 NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3919 {
3920 PyThreadState* __tstate = wxPyBeginAllowThreads();
3921 wxStartTimer();
3922
3923 wxPyEndAllowThreads(__tstate);
3924 if (PyErr_Occurred()) SWIG_fail;
3925 }
3926 Py_INCREF(Py_None); resultobj = Py_None;
3927 return resultobj;
3928 fail:
3929 return NULL;
3930 }
3931
3932
3933 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3934 PyObject *resultobj;
3935 int *arg1 = (int *) 0 ;
3936 int *arg2 = (int *) 0 ;
3937 int result;
3938 int temp1 ;
3939 int res1 = 0 ;
3940 int temp2 ;
3941 int res2 = 0 ;
3942 char *kwnames[] = {
3943 NULL
3944 };
3945
3946 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3947 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 result = (int)wxGetOsVersion(arg1,arg2);
3952
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 {
3957 resultobj = SWIG_From_int((int)(result));
3958 }
3959 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3960 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3961 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3962 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxString result;
3972 char *kwnames[] = {
3973 NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3977 {
3978 PyThreadState* __tstate = wxPyBeginAllowThreads();
3979 result = wxGetOsDescription();
3980
3981 wxPyEndAllowThreads(__tstate);
3982 if (PyErr_Occurred()) SWIG_fail;
3983 }
3984 {
3985 #if wxUSE_UNICODE
3986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3987 #else
3988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3989 #endif
3990 }
3991 return resultobj;
3992 fail:
3993 return NULL;
3994 }
3995
3996
3997 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3998 PyObject *resultobj;
3999 long result;
4000 char *kwnames[] = {
4001 NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4005 {
4006 PyThreadState* __tstate = wxPyBeginAllowThreads();
4007 result = (long)wxGetFreeMemory();
4008
4009 wxPyEndAllowThreads(__tstate);
4010 if (PyErr_Occurred()) SWIG_fail;
4011 }
4012 {
4013 resultobj = SWIG_From_long((long)(result));
4014 }
4015 return resultobj;
4016 fail:
4017 return NULL;
4018 }
4019
4020
4021 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4022 PyObject *resultobj;
4023 wxShutdownFlags arg1 ;
4024 bool result;
4025 PyObject * obj0 = 0 ;
4026 char *kwnames[] = {
4027 (char *) "wFlags", NULL
4028 };
4029
4030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4031 {
4032 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4033 if (SWIG_arg_fail(1)) SWIG_fail;
4034 }
4035 {
4036 if (!wxPyCheckForApp()) SWIG_fail;
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 {
4044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4045 }
4046 return resultobj;
4047 fail:
4048 return NULL;
4049 }
4050
4051
4052 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4053 PyObject *resultobj;
4054 int arg1 ;
4055 PyObject * obj0 = 0 ;
4056 char *kwnames[] = {
4057 (char *) "secs", NULL
4058 };
4059
4060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4061 {
4062 arg1 = (int)(SWIG_As_int(obj0));
4063 if (SWIG_arg_fail(1)) SWIG_fail;
4064 }
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 wxSleep(arg1);
4068
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 Py_INCREF(Py_None); resultobj = Py_None;
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 unsigned long arg1 ;
4082 PyObject * obj0 = 0 ;
4083 char *kwnames[] = {
4084 (char *) "milliseconds", NULL
4085 };
4086
4087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4088 {
4089 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4090 if (SWIG_arg_fail(1)) SWIG_fail;
4091 }
4092 {
4093 PyThreadState* __tstate = wxPyBeginAllowThreads();
4094 wxMilliSleep(arg1);
4095
4096 wxPyEndAllowThreads(__tstate);
4097 if (PyErr_Occurred()) SWIG_fail;
4098 }
4099 Py_INCREF(Py_None); resultobj = Py_None;
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 unsigned long arg1 ;
4109 PyObject * obj0 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "microseconds", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4115 {
4116 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 }
4119 {
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 wxMicroSleep(arg1);
4122
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 Py_INCREF(Py_None); resultobj = Py_None;
4127 return resultobj;
4128 fail:
4129 return NULL;
4130 }
4131
4132
4133 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4134 PyObject *resultobj;
4135 bool arg1 ;
4136 PyObject * obj0 = 0 ;
4137 char *kwnames[] = {
4138 (char *) "enable", NULL
4139 };
4140
4141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4142 {
4143 arg1 = (bool)(SWIG_As_bool(obj0));
4144 if (SWIG_arg_fail(1)) SWIG_fail;
4145 }
4146 {
4147 PyThreadState* __tstate = wxPyBeginAllowThreads();
4148 wxEnableTopLevelWindows(arg1);
4149
4150 wxPyEndAllowThreads(__tstate);
4151 if (PyErr_Occurred()) SWIG_fail;
4152 }
4153 Py_INCREF(Py_None); resultobj = Py_None;
4154 return resultobj;
4155 fail:
4156 return NULL;
4157 }
4158
4159
4160 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 wxString *arg1 = 0 ;
4163 wxString result;
4164 bool temp1 = false ;
4165 PyObject * obj0 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "in", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4171 {
4172 arg1 = wxString_in_helper(obj0);
4173 if (arg1 == NULL) SWIG_fail;
4174 temp1 = true;
4175 }
4176 {
4177 PyThreadState* __tstate = wxPyBeginAllowThreads();
4178 result = wxStripMenuCodes((wxString const &)*arg1);
4179
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 {
4184 #if wxUSE_UNICODE
4185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4186 #else
4187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4188 #endif
4189 }
4190 {
4191 if (temp1)
4192 delete arg1;
4193 }
4194 return resultobj;
4195 fail:
4196 {
4197 if (temp1)
4198 delete arg1;
4199 }
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 wxString result;
4207 char *kwnames[] = {
4208 NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = wxGetEmailAddress();
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 #if wxUSE_UNICODE
4221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4222 #else
4223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4224 #endif
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4233 PyObject *resultobj;
4234 wxString result;
4235 char *kwnames[] = {
4236 NULL
4237 };
4238
4239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 result = wxGetHostName();
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 {
4248 #if wxUSE_UNICODE
4249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4250 #else
4251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4252 #endif
4253 }
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxString result;
4263 char *kwnames[] = {
4264 NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxGetFullHostName();
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 {
4276 #if wxUSE_UNICODE
4277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4278 #else
4279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4280 #endif
4281 }
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4289 PyObject *resultobj;
4290 wxString result;
4291 char *kwnames[] = {
4292 NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 result = wxGetUserId();
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 {
4304 #if wxUSE_UNICODE
4305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4306 #else
4307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4308 #endif
4309 }
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj;
4318 wxString result;
4319 char *kwnames[] = {
4320 NULL
4321 };
4322
4323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4324 {
4325 PyThreadState* __tstate = wxPyBeginAllowThreads();
4326 result = wxGetUserName();
4327
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 {
4332 #if wxUSE_UNICODE
4333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4334 #else
4335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4336 #endif
4337 }
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxString result;
4347 char *kwnames[] = {
4348 NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4352 {
4353 PyThreadState* __tstate = wxPyBeginAllowThreads();
4354 result = wxGetHomeDir();
4355
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 {
4360 #if wxUSE_UNICODE
4361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4362 #else
4363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4364 #endif
4365 }
4366 return resultobj;
4367 fail:
4368 return NULL;
4369 }
4370
4371
4372 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4373 PyObject *resultobj;
4374 wxString const &arg1_defvalue = wxPyEmptyString ;
4375 wxString *arg1 = (wxString *) &arg1_defvalue ;
4376 wxString result;
4377 bool temp1 = false ;
4378 PyObject * obj0 = 0 ;
4379 char *kwnames[] = {
4380 (char *) "user", NULL
4381 };
4382
4383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4384 if (obj0) {
4385 {
4386 arg1 = wxString_in_helper(obj0);
4387 if (arg1 == NULL) SWIG_fail;
4388 temp1 = true;
4389 }
4390 }
4391 {
4392 PyThreadState* __tstate = wxPyBeginAllowThreads();
4393 result = wxGetUserHome((wxString const &)*arg1);
4394
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 {
4399 #if wxUSE_UNICODE
4400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4401 #else
4402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4403 #endif
4404 }
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return resultobj;
4410 fail:
4411 {
4412 if (temp1)
4413 delete arg1;
4414 }
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 unsigned long result;
4422 char *kwnames[] = {
4423 NULL
4424 };
4425
4426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = (unsigned long)wxGetProcessId();
4430
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4436 }
4437 return resultobj;
4438 fail:
4439 return NULL;
4440 }
4441
4442
4443 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4444 PyObject *resultobj;
4445 char *kwnames[] = {
4446 NULL
4447 };
4448
4449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4450 {
4451 PyThreadState* __tstate = wxPyBeginAllowThreads();
4452 wxTrap();
4453
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 Py_INCREF(Py_None); resultobj = Py_None;
4458 return resultobj;
4459 fail:
4460 return NULL;
4461 }
4462
4463
4464 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj;
4466 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4467 wxString *arg1 = (wxString *) &arg1_defvalue ;
4468 wxString const &arg2_defvalue = wxPyEmptyString ;
4469 wxString *arg2 = (wxString *) &arg2_defvalue ;
4470 wxString const &arg3_defvalue = wxPyEmptyString ;
4471 wxString *arg3 = (wxString *) &arg3_defvalue ;
4472 wxString const &arg4_defvalue = wxPyEmptyString ;
4473 wxString *arg4 = (wxString *) &arg4_defvalue ;
4474 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4475 wxString *arg5 = (wxString *) &arg5_defvalue ;
4476 int arg6 = (int) 0 ;
4477 wxWindow *arg7 = (wxWindow *) NULL ;
4478 int arg8 = (int) -1 ;
4479 int arg9 = (int) -1 ;
4480 wxString result;
4481 bool temp1 = false ;
4482 bool temp2 = false ;
4483 bool temp3 = false ;
4484 bool temp4 = false ;
4485 bool temp5 = false ;
4486 PyObject * obj0 = 0 ;
4487 PyObject * obj1 = 0 ;
4488 PyObject * obj2 = 0 ;
4489 PyObject * obj3 = 0 ;
4490 PyObject * obj4 = 0 ;
4491 PyObject * obj5 = 0 ;
4492 PyObject * obj6 = 0 ;
4493 PyObject * obj7 = 0 ;
4494 PyObject * obj8 = 0 ;
4495 char *kwnames[] = {
4496 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4497 };
4498
4499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4500 if (obj0) {
4501 {
4502 arg1 = wxString_in_helper(obj0);
4503 if (arg1 == NULL) SWIG_fail;
4504 temp1 = true;
4505 }
4506 }
4507 if (obj1) {
4508 {
4509 arg2 = wxString_in_helper(obj1);
4510 if (arg2 == NULL) SWIG_fail;
4511 temp2 = true;
4512 }
4513 }
4514 if (obj2) {
4515 {
4516 arg3 = wxString_in_helper(obj2);
4517 if (arg3 == NULL) SWIG_fail;
4518 temp3 = true;
4519 }
4520 }
4521 if (obj3) {
4522 {
4523 arg4 = wxString_in_helper(obj3);
4524 if (arg4 == NULL) SWIG_fail;
4525 temp4 = true;
4526 }
4527 }
4528 if (obj4) {
4529 {
4530 arg5 = wxString_in_helper(obj4);
4531 if (arg5 == NULL) SWIG_fail;
4532 temp5 = true;
4533 }
4534 }
4535 if (obj5) {
4536 {
4537 arg6 = (int)(SWIG_As_int(obj5));
4538 if (SWIG_arg_fail(6)) SWIG_fail;
4539 }
4540 }
4541 if (obj6) {
4542 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4543 if (SWIG_arg_fail(7)) SWIG_fail;
4544 }
4545 if (obj7) {
4546 {
4547 arg8 = (int)(SWIG_As_int(obj7));
4548 if (SWIG_arg_fail(8)) SWIG_fail;
4549 }
4550 }
4551 if (obj8) {
4552 {
4553 arg9 = (int)(SWIG_As_int(obj8));
4554 if (SWIG_arg_fail(9)) SWIG_fail;
4555 }
4556 }
4557 {
4558 if (!wxPyCheckForApp()) SWIG_fail;
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4561
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 {
4566 #if wxUSE_UNICODE
4567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4568 #else
4569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4570 #endif
4571 }
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 {
4577 if (temp2)
4578 delete arg2;
4579 }
4580 {
4581 if (temp3)
4582 delete arg3;
4583 }
4584 {
4585 if (temp4)
4586 delete arg4;
4587 }
4588 {
4589 if (temp5)
4590 delete arg5;
4591 }
4592 return resultobj;
4593 fail:
4594 {
4595 if (temp1)
4596 delete arg1;
4597 }
4598 {
4599 if (temp2)
4600 delete arg2;
4601 }
4602 {
4603 if (temp3)
4604 delete arg3;
4605 }
4606 {
4607 if (temp4)
4608 delete arg4;
4609 }
4610 {
4611 if (temp5)
4612 delete arg5;
4613 }
4614 return NULL;
4615 }
4616
4617
4618 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4619 PyObject *resultobj;
4620 wxString *arg1 = 0 ;
4621 wxString *arg2 = 0 ;
4622 wxString const &arg3_defvalue = wxPyEmptyString ;
4623 wxString *arg3 = (wxString *) &arg3_defvalue ;
4624 wxWindow *arg4 = (wxWindow *) NULL ;
4625 wxString result;
4626 bool temp1 = false ;
4627 bool temp2 = false ;
4628 bool temp3 = false ;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 PyObject * obj2 = 0 ;
4632 PyObject * obj3 = 0 ;
4633 char *kwnames[] = {
4634 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4635 };
4636
4637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4638 {
4639 arg1 = wxString_in_helper(obj0);
4640 if (arg1 == NULL) SWIG_fail;
4641 temp1 = true;
4642 }
4643 {
4644 arg2 = wxString_in_helper(obj1);
4645 if (arg2 == NULL) SWIG_fail;
4646 temp2 = true;
4647 }
4648 if (obj2) {
4649 {
4650 arg3 = wxString_in_helper(obj2);
4651 if (arg3 == NULL) SWIG_fail;
4652 temp3 = true;
4653 }
4654 }
4655 if (obj3) {
4656 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4657 if (SWIG_arg_fail(4)) SWIG_fail;
4658 }
4659 {
4660 if (!wxPyCheckForApp()) SWIG_fail;
4661 PyThreadState* __tstate = wxPyBeginAllowThreads();
4662 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4663
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 {
4668 #if wxUSE_UNICODE
4669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4670 #else
4671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4672 #endif
4673 }
4674 {
4675 if (temp1)
4676 delete arg1;
4677 }
4678 {
4679 if (temp2)
4680 delete arg2;
4681 }
4682 {
4683 if (temp3)
4684 delete arg3;
4685 }
4686 return resultobj;
4687 fail:
4688 {
4689 if (temp1)
4690 delete arg1;
4691 }
4692 {
4693 if (temp2)
4694 delete arg2;
4695 }
4696 {
4697 if (temp3)
4698 delete arg3;
4699 }
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj;
4706 wxString *arg1 = 0 ;
4707 wxString *arg2 = 0 ;
4708 wxString const &arg3_defvalue = wxPyEmptyString ;
4709 wxString *arg3 = (wxString *) &arg3_defvalue ;
4710 wxWindow *arg4 = (wxWindow *) NULL ;
4711 wxString result;
4712 bool temp1 = false ;
4713 bool temp2 = false ;
4714 bool temp3 = false ;
4715 PyObject * obj0 = 0 ;
4716 PyObject * obj1 = 0 ;
4717 PyObject * obj2 = 0 ;
4718 PyObject * obj3 = 0 ;
4719 char *kwnames[] = {
4720 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4721 };
4722
4723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4724 {
4725 arg1 = wxString_in_helper(obj0);
4726 if (arg1 == NULL) SWIG_fail;
4727 temp1 = true;
4728 }
4729 {
4730 arg2 = wxString_in_helper(obj1);
4731 if (arg2 == NULL) SWIG_fail;
4732 temp2 = true;
4733 }
4734 if (obj2) {
4735 {
4736 arg3 = wxString_in_helper(obj2);
4737 if (arg3 == NULL) SWIG_fail;
4738 temp3 = true;
4739 }
4740 }
4741 if (obj3) {
4742 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4743 if (SWIG_arg_fail(4)) SWIG_fail;
4744 }
4745 {
4746 if (!wxPyCheckForApp()) SWIG_fail;
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4749
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 {
4754 #if wxUSE_UNICODE
4755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4756 #else
4757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4758 #endif
4759 }
4760 {
4761 if (temp1)
4762 delete arg1;
4763 }
4764 {
4765 if (temp2)
4766 delete arg2;
4767 }
4768 {
4769 if (temp3)
4770 delete arg3;
4771 }
4772 return resultobj;
4773 fail:
4774 {
4775 if (temp1)
4776 delete arg1;
4777 }
4778 {
4779 if (temp2)
4780 delete arg2;
4781 }
4782 {
4783 if (temp3)
4784 delete arg3;
4785 }
4786 return NULL;
4787 }
4788
4789
4790 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4791 PyObject *resultobj;
4792 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4793 wxString *arg1 = (wxString *) &arg1_defvalue ;
4794 wxString const &arg2_defvalue = wxPyEmptyString ;
4795 wxString *arg2 = (wxString *) &arg2_defvalue ;
4796 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4797 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4798 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4799 wxWindow *arg5 = (wxWindow *) NULL ;
4800 wxString result;
4801 bool temp1 = false ;
4802 bool temp2 = false ;
4803 wxPoint temp4 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 PyObject * obj2 = 0 ;
4807 PyObject * obj3 = 0 ;
4808 PyObject * obj4 = 0 ;
4809 char *kwnames[] = {
4810 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4811 };
4812
4813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4814 if (obj0) {
4815 {
4816 arg1 = wxString_in_helper(obj0);
4817 if (arg1 == NULL) SWIG_fail;
4818 temp1 = true;
4819 }
4820 }
4821 if (obj1) {
4822 {
4823 arg2 = wxString_in_helper(obj1);
4824 if (arg2 == NULL) SWIG_fail;
4825 temp2 = true;
4826 }
4827 }
4828 if (obj2) {
4829 {
4830 arg3 = (long)(SWIG_As_long(obj2));
4831 if (SWIG_arg_fail(3)) SWIG_fail;
4832 }
4833 }
4834 if (obj3) {
4835 {
4836 arg4 = &temp4;
4837 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4838 }
4839 }
4840 if (obj4) {
4841 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4842 if (SWIG_arg_fail(5)) SWIG_fail;
4843 }
4844 {
4845 if (!wxPyCheckForApp()) SWIG_fail;
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4848
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 {
4853 #if wxUSE_UNICODE
4854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4855 #else
4856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4857 #endif
4858 }
4859 {
4860 if (temp1)
4861 delete arg1;
4862 }
4863 {
4864 if (temp2)
4865 delete arg2;
4866 }
4867 return resultobj;
4868 fail:
4869 {
4870 if (temp1)
4871 delete arg1;
4872 }
4873 {
4874 if (temp2)
4875 delete arg2;
4876 }
4877 return NULL;
4878 }
4879
4880
4881 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj;
4883 wxString *arg1 = 0 ;
4884 wxString const &arg2_defvalue = wxPyEmptyString ;
4885 wxString *arg2 = (wxString *) &arg2_defvalue ;
4886 wxString const &arg3_defvalue = wxPyEmptyString ;
4887 wxString *arg3 = (wxString *) &arg3_defvalue ;
4888 wxWindow *arg4 = (wxWindow *) NULL ;
4889 int arg5 = (int) -1 ;
4890 int arg6 = (int) -1 ;
4891 bool arg7 = (bool) true ;
4892 wxString result;
4893 bool temp1 = false ;
4894 bool temp2 = false ;
4895 bool temp3 = false ;
4896 PyObject * obj0 = 0 ;
4897 PyObject * obj1 = 0 ;
4898 PyObject * obj2 = 0 ;
4899 PyObject * obj3 = 0 ;
4900 PyObject * obj4 = 0 ;
4901 PyObject * obj5 = 0 ;
4902 PyObject * obj6 = 0 ;
4903 char *kwnames[] = {
4904 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4905 };
4906
4907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4908 {
4909 arg1 = wxString_in_helper(obj0);
4910 if (arg1 == NULL) SWIG_fail;
4911 temp1 = true;
4912 }
4913 if (obj1) {
4914 {
4915 arg2 = wxString_in_helper(obj1);
4916 if (arg2 == NULL) SWIG_fail;
4917 temp2 = true;
4918 }
4919 }
4920 if (obj2) {
4921 {
4922 arg3 = wxString_in_helper(obj2);
4923 if (arg3 == NULL) SWIG_fail;
4924 temp3 = true;
4925 }
4926 }
4927 if (obj3) {
4928 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4929 if (SWIG_arg_fail(4)) SWIG_fail;
4930 }
4931 if (obj4) {
4932 {
4933 arg5 = (int)(SWIG_As_int(obj4));
4934 if (SWIG_arg_fail(5)) SWIG_fail;
4935 }
4936 }
4937 if (obj5) {
4938 {
4939 arg6 = (int)(SWIG_As_int(obj5));
4940 if (SWIG_arg_fail(6)) SWIG_fail;
4941 }
4942 }
4943 if (obj6) {
4944 {
4945 arg7 = (bool)(SWIG_As_bool(obj6));
4946 if (SWIG_arg_fail(7)) SWIG_fail;
4947 }
4948 }
4949 {
4950 if (!wxPyCheckForApp()) SWIG_fail;
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 {
4958 #if wxUSE_UNICODE
4959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4960 #else
4961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4962 #endif
4963 }
4964 {
4965 if (temp1)
4966 delete arg1;
4967 }
4968 {
4969 if (temp2)
4970 delete arg2;
4971 }
4972 {
4973 if (temp3)
4974 delete arg3;
4975 }
4976 return resultobj;
4977 fail:
4978 {
4979 if (temp1)
4980 delete arg1;
4981 }
4982 {
4983 if (temp2)
4984 delete arg2;
4985 }
4986 {
4987 if (temp3)
4988 delete arg3;
4989 }
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxString *arg1 = 0 ;
4997 wxString const &arg2_defvalue = wxPyEmptyString ;
4998 wxString *arg2 = (wxString *) &arg2_defvalue ;
4999 wxString const &arg3_defvalue = wxPyEmptyString ;
5000 wxString *arg3 = (wxString *) &arg3_defvalue ;
5001 wxWindow *arg4 = (wxWindow *) NULL ;
5002 wxString result;
5003 bool temp1 = false ;
5004 bool temp2 = false ;
5005 bool temp3 = false ;
5006 PyObject * obj0 = 0 ;
5007 PyObject * obj1 = 0 ;
5008 PyObject * obj2 = 0 ;
5009 PyObject * obj3 = 0 ;
5010 char *kwnames[] = {
5011 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5012 };
5013
5014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5015 {
5016 arg1 = wxString_in_helper(obj0);
5017 if (arg1 == NULL) SWIG_fail;
5018 temp1 = true;
5019 }
5020 if (obj1) {
5021 {
5022 arg2 = wxString_in_helper(obj1);
5023 if (arg2 == NULL) SWIG_fail;
5024 temp2 = true;
5025 }
5026 }
5027 if (obj2) {
5028 {
5029 arg3 = wxString_in_helper(obj2);
5030 if (arg3 == NULL) SWIG_fail;
5031 temp3 = true;
5032 }
5033 }
5034 if (obj3) {
5035 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5036 if (SWIG_arg_fail(4)) SWIG_fail;
5037 }
5038 {
5039 if (!wxPyCheckForApp()) SWIG_fail;
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5042
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 {
5047 #if wxUSE_UNICODE
5048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5049 #else
5050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5051 #endif
5052 }
5053 {
5054 if (temp1)
5055 delete arg1;
5056 }
5057 {
5058 if (temp2)
5059 delete arg2;
5060 }
5061 {
5062 if (temp3)
5063 delete arg3;
5064 }
5065 return resultobj;
5066 fail:
5067 {
5068 if (temp1)
5069 delete arg1;
5070 }
5071 {
5072 if (temp2)
5073 delete arg2;
5074 }
5075 {
5076 if (temp3)
5077 delete arg3;
5078 }
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 wxString *arg1 = 0 ;
5086 wxString *arg2 = 0 ;
5087 int arg3 ;
5088 wxString *arg4 = (wxString *) 0 ;
5089 wxWindow *arg5 = (wxWindow *) NULL ;
5090 int arg6 = (int) -1 ;
5091 int arg7 = (int) -1 ;
5092 bool arg8 = (bool) true ;
5093 int arg9 = (int) 150 ;
5094 int arg10 = (int) 200 ;
5095 wxString result;
5096 bool temp1 = false ;
5097 bool temp2 = false ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 PyObject * obj2 = 0 ;
5101 PyObject * obj3 = 0 ;
5102 PyObject * obj4 = 0 ;
5103 PyObject * obj5 = 0 ;
5104 PyObject * obj6 = 0 ;
5105 PyObject * obj7 = 0 ;
5106 PyObject * obj8 = 0 ;
5107 char *kwnames[] = {
5108 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5109 };
5110
5111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5112 {
5113 arg1 = wxString_in_helper(obj0);
5114 if (arg1 == NULL) SWIG_fail;
5115 temp1 = true;
5116 }
5117 {
5118 arg2 = wxString_in_helper(obj1);
5119 if (arg2 == NULL) SWIG_fail;
5120 temp2 = true;
5121 }
5122 {
5123 arg3 = PyList_Size(obj2);
5124 arg4 = wxString_LIST_helper(obj2);
5125 if (arg4 == NULL) SWIG_fail;
5126 }
5127 if (obj3) {
5128 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5129 if (SWIG_arg_fail(5)) SWIG_fail;
5130 }
5131 if (obj4) {
5132 {
5133 arg6 = (int)(SWIG_As_int(obj4));
5134 if (SWIG_arg_fail(6)) SWIG_fail;
5135 }
5136 }
5137 if (obj5) {
5138 {
5139 arg7 = (int)(SWIG_As_int(obj5));
5140 if (SWIG_arg_fail(7)) SWIG_fail;
5141 }
5142 }
5143 if (obj6) {
5144 {
5145 arg8 = (bool)(SWIG_As_bool(obj6));
5146 if (SWIG_arg_fail(8)) SWIG_fail;
5147 }
5148 }
5149 if (obj7) {
5150 {
5151 arg9 = (int)(SWIG_As_int(obj7));
5152 if (SWIG_arg_fail(9)) SWIG_fail;
5153 }
5154 }
5155 if (obj8) {
5156 {
5157 arg10 = (int)(SWIG_As_int(obj8));
5158 if (SWIG_arg_fail(10)) SWIG_fail;
5159 }
5160 }
5161 {
5162 if (!wxPyCheckForApp()) SWIG_fail;
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5165
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 {
5170 #if wxUSE_UNICODE
5171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5172 #else
5173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5174 #endif
5175 }
5176 {
5177 if (temp1)
5178 delete arg1;
5179 }
5180 {
5181 if (temp2)
5182 delete arg2;
5183 }
5184 {
5185 if (arg4) delete [] arg4;
5186 }
5187 return resultobj;
5188 fail:
5189 {
5190 if (temp1)
5191 delete arg1;
5192 }
5193 {
5194 if (temp2)
5195 delete arg2;
5196 }
5197 {
5198 if (arg4) delete [] arg4;
5199 }
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxString *arg1 = 0 ;
5207 wxString *arg2 = 0 ;
5208 int arg3 ;
5209 wxString *arg4 = (wxString *) 0 ;
5210 wxWindow *arg5 = (wxWindow *) NULL ;
5211 int arg6 = (int) -1 ;
5212 int arg7 = (int) -1 ;
5213 bool arg8 = (bool) true ;
5214 int arg9 = (int) 150 ;
5215 int arg10 = (int) 200 ;
5216 int result;
5217 bool temp1 = false ;
5218 bool temp2 = false ;
5219 PyObject * obj0 = 0 ;
5220 PyObject * obj1 = 0 ;
5221 PyObject * obj2 = 0 ;
5222 PyObject * obj3 = 0 ;
5223 PyObject * obj4 = 0 ;
5224 PyObject * obj5 = 0 ;
5225 PyObject * obj6 = 0 ;
5226 PyObject * obj7 = 0 ;
5227 PyObject * obj8 = 0 ;
5228 char *kwnames[] = {
5229 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5230 };
5231
5232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5233 {
5234 arg1 = wxString_in_helper(obj0);
5235 if (arg1 == NULL) SWIG_fail;
5236 temp1 = true;
5237 }
5238 {
5239 arg2 = wxString_in_helper(obj1);
5240 if (arg2 == NULL) SWIG_fail;
5241 temp2 = true;
5242 }
5243 {
5244 arg3 = PyList_Size(obj2);
5245 arg4 = wxString_LIST_helper(obj2);
5246 if (arg4 == NULL) SWIG_fail;
5247 }
5248 if (obj3) {
5249 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5250 if (SWIG_arg_fail(5)) SWIG_fail;
5251 }
5252 if (obj4) {
5253 {
5254 arg6 = (int)(SWIG_As_int(obj4));
5255 if (SWIG_arg_fail(6)) SWIG_fail;
5256 }
5257 }
5258 if (obj5) {
5259 {
5260 arg7 = (int)(SWIG_As_int(obj5));
5261 if (SWIG_arg_fail(7)) SWIG_fail;
5262 }
5263 }
5264 if (obj6) {
5265 {
5266 arg8 = (bool)(SWIG_As_bool(obj6));
5267 if (SWIG_arg_fail(8)) SWIG_fail;
5268 }
5269 }
5270 if (obj7) {
5271 {
5272 arg9 = (int)(SWIG_As_int(obj7));
5273 if (SWIG_arg_fail(9)) SWIG_fail;
5274 }
5275 }
5276 if (obj8) {
5277 {
5278 arg10 = (int)(SWIG_As_int(obj8));
5279 if (SWIG_arg_fail(10)) SWIG_fail;
5280 }
5281 }
5282 {
5283 if (!wxPyCheckForApp()) SWIG_fail;
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5286
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 {
5291 resultobj = SWIG_From_int((int)(result));
5292 }
5293 {
5294 if (temp1)
5295 delete arg1;
5296 }
5297 {
5298 if (temp2)
5299 delete arg2;
5300 }
5301 {
5302 if (arg4) delete [] arg4;
5303 }
5304 return resultobj;
5305 fail:
5306 {
5307 if (temp1)
5308 delete arg1;
5309 }
5310 {
5311 if (temp2)
5312 delete arg2;
5313 }
5314 {
5315 if (arg4) delete [] arg4;
5316 }
5317 return NULL;
5318 }
5319
5320
5321 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5322 PyObject *resultobj;
5323 wxString *arg1 = 0 ;
5324 wxString const &arg2_defvalue = wxPyEmptyString ;
5325 wxString *arg2 = (wxString *) &arg2_defvalue ;
5326 int arg3 = (int) wxOK|wxCENTRE ;
5327 wxWindow *arg4 = (wxWindow *) NULL ;
5328 int arg5 = (int) -1 ;
5329 int arg6 = (int) -1 ;
5330 int result;
5331 bool temp1 = false ;
5332 bool temp2 = false ;
5333 PyObject * obj0 = 0 ;
5334 PyObject * obj1 = 0 ;
5335 PyObject * obj2 = 0 ;
5336 PyObject * obj3 = 0 ;
5337 PyObject * obj4 = 0 ;
5338 PyObject * obj5 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5344 {
5345 arg1 = wxString_in_helper(obj0);
5346 if (arg1 == NULL) SWIG_fail;
5347 temp1 = true;
5348 }
5349 if (obj1) {
5350 {
5351 arg2 = wxString_in_helper(obj1);
5352 if (arg2 == NULL) SWIG_fail;
5353 temp2 = true;
5354 }
5355 }
5356 if (obj2) {
5357 {
5358 arg3 = (int)(SWIG_As_int(obj2));
5359 if (SWIG_arg_fail(3)) SWIG_fail;
5360 }
5361 }
5362 if (obj3) {
5363 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5364 if (SWIG_arg_fail(4)) SWIG_fail;
5365 }
5366 if (obj4) {
5367 {
5368 arg5 = (int)(SWIG_As_int(obj4));
5369 if (SWIG_arg_fail(5)) SWIG_fail;
5370 }
5371 }
5372 if (obj5) {
5373 {
5374 arg6 = (int)(SWIG_As_int(obj5));
5375 if (SWIG_arg_fail(6)) SWIG_fail;
5376 }
5377 }
5378 {
5379 if (!wxPyCheckForApp()) SWIG_fail;
5380 PyThreadState* __tstate = wxPyBeginAllowThreads();
5381 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5382
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 resultobj = SWIG_From_int((int)(result));
5388 }
5389 {
5390 if (temp1)
5391 delete arg1;
5392 }
5393 {
5394 if (temp2)
5395 delete arg2;
5396 }
5397 return resultobj;
5398 fail:
5399 {
5400 if (temp1)
5401 delete arg1;
5402 }
5403 {
5404 if (temp2)
5405 delete arg2;
5406 }
5407 return NULL;
5408 }
5409
5410
5411 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj;
5413 wxString *arg1 = 0 ;
5414 wxString *arg2 = 0 ;
5415 wxString *arg3 = 0 ;
5416 long arg4 ;
5417 long arg5 = (long) 0 ;
5418 long arg6 = (long) 100 ;
5419 wxWindow *arg7 = (wxWindow *) NULL ;
5420 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5421 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5422 long result;
5423 bool temp1 = false ;
5424 bool temp2 = false ;
5425 bool temp3 = false ;
5426 wxPoint temp8 ;
5427 PyObject * obj0 = 0 ;
5428 PyObject * obj1 = 0 ;
5429 PyObject * obj2 = 0 ;
5430 PyObject * obj3 = 0 ;
5431 PyObject * obj4 = 0 ;
5432 PyObject * obj5 = 0 ;
5433 PyObject * obj6 = 0 ;
5434 PyObject * obj7 = 0 ;
5435 char *kwnames[] = {
5436 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5437 };
5438
5439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5440 {
5441 arg1 = wxString_in_helper(obj0);
5442 if (arg1 == NULL) SWIG_fail;
5443 temp1 = true;
5444 }
5445 {
5446 arg2 = wxString_in_helper(obj1);
5447 if (arg2 == NULL) SWIG_fail;
5448 temp2 = true;
5449 }
5450 {
5451 arg3 = wxString_in_helper(obj2);
5452 if (arg3 == NULL) SWIG_fail;
5453 temp3 = true;
5454 }
5455 {
5456 arg4 = (long)(SWIG_As_long(obj3));
5457 if (SWIG_arg_fail(4)) SWIG_fail;
5458 }
5459 if (obj4) {
5460 {
5461 arg5 = (long)(SWIG_As_long(obj4));
5462 if (SWIG_arg_fail(5)) SWIG_fail;
5463 }
5464 }
5465 if (obj5) {
5466 {
5467 arg6 = (long)(SWIG_As_long(obj5));
5468 if (SWIG_arg_fail(6)) SWIG_fail;
5469 }
5470 }
5471 if (obj6) {
5472 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(7)) SWIG_fail;
5474 }
5475 if (obj7) {
5476 {
5477 arg8 = &temp8;
5478 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5479 }
5480 }
5481 {
5482 if (!wxPyCheckForApp()) SWIG_fail;
5483 PyThreadState* __tstate = wxPyBeginAllowThreads();
5484 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5485
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 {
5490 resultobj = SWIG_From_long((long)(result));
5491 }
5492 {
5493 if (temp1)
5494 delete arg1;
5495 }
5496 {
5497 if (temp2)
5498 delete arg2;
5499 }
5500 {
5501 if (temp3)
5502 delete arg3;
5503 }
5504 return resultobj;
5505 fail:
5506 {
5507 if (temp1)
5508 delete arg1;
5509 }
5510 {
5511 if (temp2)
5512 delete arg2;
5513 }
5514 {
5515 if (temp3)
5516 delete arg3;
5517 }
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj;
5524 bool result;
5525 char *kwnames[] = {
5526 NULL
5527 };
5528
5529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5530 {
5531 if (!wxPyCheckForApp()) SWIG_fail;
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = (bool)wxColourDisplay();
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 {
5539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5540 }
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj;
5549 int result;
5550 char *kwnames[] = {
5551 NULL
5552 };
5553
5554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5555 {
5556 if (!wxPyCheckForApp()) SWIG_fail;
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 result = (int)wxDisplayDepth();
5559
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 {
5564 resultobj = SWIG_From_int((int)(result));
5565 }
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5573 PyObject *resultobj;
5574 int result;
5575 char *kwnames[] = {
5576 NULL
5577 };
5578
5579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5580 {
5581 if (!wxPyCheckForApp()) SWIG_fail;
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 result = (int)wxGetDisplayDepth();
5584
5585 wxPyEndAllowThreads(__tstate);
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 {
5589 resultobj = SWIG_From_int((int)(result));
5590 }
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj;
5599 int *arg1 = (int *) 0 ;
5600 int *arg2 = (int *) 0 ;
5601 int temp1 ;
5602 int res1 = 0 ;
5603 int temp2 ;
5604 int res2 = 0 ;
5605 char *kwnames[] = {
5606 NULL
5607 };
5608
5609 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5610 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5612 {
5613 if (!wxPyCheckForApp()) SWIG_fail;
5614 PyThreadState* __tstate = wxPyBeginAllowThreads();
5615 wxDisplaySize(arg1,arg2);
5616
5617 wxPyEndAllowThreads(__tstate);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 Py_INCREF(Py_None); resultobj = Py_None;
5621 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5622 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5623 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5624 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj;
5633 wxSize result;
5634 char *kwnames[] = {
5635 NULL
5636 };
5637
5638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5639 {
5640 if (!wxPyCheckForApp()) SWIG_fail;
5641 PyThreadState* __tstate = wxPyBeginAllowThreads();
5642 result = wxGetDisplaySize();
5643
5644 wxPyEndAllowThreads(__tstate);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 {
5648 wxSize * resultptr;
5649 resultptr = new wxSize((wxSize &)(result));
5650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5651 }
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 int *arg1 = (int *) 0 ;
5661 int *arg2 = (int *) 0 ;
5662 int temp1 ;
5663 int res1 = 0 ;
5664 int temp2 ;
5665 int res2 = 0 ;
5666 char *kwnames[] = {
5667 NULL
5668 };
5669
5670 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5671 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5673 {
5674 if (!wxPyCheckForApp()) SWIG_fail;
5675 PyThreadState* __tstate = wxPyBeginAllowThreads();
5676 wxDisplaySizeMM(arg1,arg2);
5677
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 Py_INCREF(Py_None); resultobj = Py_None;
5682 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5683 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5684 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5685 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5686 return resultobj;
5687 fail:
5688 return NULL;
5689 }
5690
5691
5692 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5693 PyObject *resultobj;
5694 wxSize result;
5695 char *kwnames[] = {
5696 NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5700 {
5701 if (!wxPyCheckForApp()) SWIG_fail;
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = wxGetDisplaySizeMM();
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 {
5709 wxSize * resultptr;
5710 resultptr = new wxSize((wxSize &)(result));
5711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5712 }
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj;
5721 int *arg1 = (int *) 0 ;
5722 int *arg2 = (int *) 0 ;
5723 int *arg3 = (int *) 0 ;
5724 int *arg4 = (int *) 0 ;
5725 int temp1 ;
5726 int res1 = 0 ;
5727 int temp2 ;
5728 int res2 = 0 ;
5729 int temp3 ;
5730 int res3 = 0 ;
5731 int temp4 ;
5732 int res4 = 0 ;
5733 char *kwnames[] = {
5734 NULL
5735 };
5736
5737 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5738 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5739 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5740 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5742 {
5743 if (!wxPyCheckForApp()) SWIG_fail;
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5746
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 Py_INCREF(Py_None); resultobj = Py_None;
5751 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5752 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5753 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5754 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5755 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5756 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5757 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5758 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj;
5767 wxRect result;
5768 char *kwnames[] = {
5769 NULL
5770 };
5771
5772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5773 {
5774 if (!wxPyCheckForApp()) SWIG_fail;
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = wxGetClientDisplayRect();
5777
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 {
5782 wxRect * resultptr;
5783 resultptr = new wxRect((wxRect &)(result));
5784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5785 }
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj;
5794 wxCursor *arg1 = 0 ;
5795 PyObject * obj0 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "cursor", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5801 {
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 if (arg1 == NULL) {
5805 SWIG_null_ref("wxCursor");
5806 }
5807 if (SWIG_arg_fail(1)) SWIG_fail;
5808 }
5809 {
5810 if (!wxPyCheckForApp()) SWIG_fail;
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 wxSetCursor(*arg1);
5813
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 Py_INCREF(Py_None); resultobj = Py_None;
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5825 PyObject *resultobj;
5826 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5827 PyObject * obj0 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "cursor", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5833 if (obj0) {
5834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5835 if (SWIG_arg_fail(1)) SWIG_fail;
5836 }
5837 {
5838 if (!wxPyCheckForApp()) SWIG_fail;
5839 PyThreadState* __tstate = wxPyBeginAllowThreads();
5840 wxBeginBusyCursor(arg1);
5841
5842 wxPyEndAllowThreads(__tstate);
5843 if (PyErr_Occurred()) SWIG_fail;
5844 }
5845 Py_INCREF(Py_None); resultobj = Py_None;
5846 return resultobj;
5847 fail:
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj;
5854 wxWindow *result;
5855 char *kwnames[] = {
5856 NULL
5857 };
5858
5859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5860 {
5861 if (!wxPyCheckForApp()) SWIG_fail;
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 result = (wxWindow *)wxGetActiveWindow();
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 {
5869 resultobj = wxPyMake_wxObject(result, 0);
5870 }
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 wxPoint *arg1 = 0 ;
5880 wxWindow *result;
5881 wxPoint temp1 ;
5882 PyObject * obj0 = 0 ;
5883 char *kwnames[] = {
5884 (char *) "pt", NULL
5885 };
5886
5887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5888 {
5889 arg1 = &temp1;
5890 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5891 }
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 resultobj = wxPyMake_wxObject(result, 0);
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj;
5911 wxPoint *arg1 = 0 ;
5912 wxWindow *result;
5913 wxPoint temp1 ;
5914 PyObject * obj0 = 0 ;
5915 char *kwnames[] = {
5916 (char *) "pt", NULL
5917 };
5918
5919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5920 {
5921 arg1 = &temp1;
5922 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5923 }
5924 {
5925 if (!wxPyCheckForApp()) SWIG_fail;
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 {
5933 resultobj = wxPyMake_wxObject(result, 0);
5934 }
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj;
5943 wxWindow *arg1 = (wxWindow *) 0 ;
5944 wxWindow *result;
5945 PyObject * obj0 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "win", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 {
5954 if (!wxPyCheckForApp()) SWIG_fail;
5955 PyThreadState* __tstate = wxPyBeginAllowThreads();
5956 result = (wxWindow *)wxGetTopLevelParent(arg1);
5957
5958 wxPyEndAllowThreads(__tstate);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 {
5962 resultobj = wxPyMake_wxObject(result, 0);
5963 }
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5971 PyObject *resultobj;
5972 wxKeyCode arg1 ;
5973 bool result;
5974 PyObject * obj0 = 0 ;
5975 char *kwnames[] = {
5976 (char *) "key", NULL
5977 };
5978
5979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5980 {
5981 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 }
5984 {
5985 if (!wxPyCheckForApp()) SWIG_fail;
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5988
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 {
5993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5994 }
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj;
6003 char *kwnames[] = {
6004 NULL
6005 };
6006
6007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6008 {
6009 if (!wxPyCheckForApp()) SWIG_fail;
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 wxWakeUpMainThread();
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 Py_INCREF(Py_None); resultobj = Py_None;
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 char *kwnames[] = {
6026 NULL
6027 };
6028
6029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6030 {
6031 if (!wxPyCheckForApp()) SWIG_fail;
6032 PyThreadState* __tstate = wxPyBeginAllowThreads();
6033 wxMutexGuiEnter();
6034
6035 wxPyEndAllowThreads(__tstate);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 Py_INCREF(Py_None); resultobj = Py_None;
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 char *kwnames[] = {
6048 NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6052 {
6053 if (!wxPyCheckForApp()) SWIG_fail;
6054 PyThreadState* __tstate = wxPyBeginAllowThreads();
6055 wxMutexGuiLeave();
6056
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 Py_INCREF(Py_None); resultobj = Py_None;
6061 return resultobj;
6062 fail:
6063 return NULL;
6064 }
6065
6066
6067 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj;
6069 wxMutexGuiLocker *result;
6070 char *kwnames[] = {
6071 NULL
6072 };
6073
6074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6075 {
6076 if (!wxPyCheckForApp()) SWIG_fail;
6077 PyThreadState* __tstate = wxPyBeginAllowThreads();
6078 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6079
6080 wxPyEndAllowThreads(__tstate);
6081 if (PyErr_Occurred()) SWIG_fail;
6082 }
6083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6084 return resultobj;
6085 fail:
6086 return NULL;
6087 }
6088
6089
6090 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6091 PyObject *resultobj;
6092 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6093 PyObject * obj0 = 0 ;
6094 char *kwnames[] = {
6095 (char *) "self", NULL
6096 };
6097
6098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6100 if (SWIG_arg_fail(1)) SWIG_fail;
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 delete arg1;
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 * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6116 PyObject *obj;
6117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6118 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6119 Py_INCREF(obj);
6120 return Py_BuildValue((char *)"");
6121 }
6122 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6123 PyObject *resultobj;
6124 bool result;
6125 char *kwnames[] = {
6126 NULL
6127 };
6128
6129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = (bool)wxThread_IsMain();
6133
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 {
6138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6139 }
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj;
6148 wxString *arg1 = 0 ;
6149 wxToolTip *result;
6150 bool temp1 = false ;
6151 PyObject * obj0 = 0 ;
6152 char *kwnames[] = {
6153 (char *) "tip", NULL
6154 };
6155
6156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6157 {
6158 arg1 = wxString_in_helper(obj0);
6159 if (arg1 == NULL) SWIG_fail;
6160 temp1 = true;
6161 }
6162 {
6163 if (!wxPyCheckForApp()) SWIG_fail;
6164 PyThreadState* __tstate = wxPyBeginAllowThreads();
6165 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6166
6167 wxPyEndAllowThreads(__tstate);
6168 if (PyErr_Occurred()) SWIG_fail;
6169 }
6170 {
6171 resultobj = wxPyMake_wxObject(result, 1);
6172 }
6173 {
6174 if (temp1)
6175 delete arg1;
6176 }
6177 return resultobj;
6178 fail:
6179 {
6180 if (temp1)
6181 delete arg1;
6182 }
6183 return NULL;
6184 }
6185
6186
6187 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj;
6189 wxToolTip *arg1 = (wxToolTip *) 0 ;
6190 wxString *arg2 = 0 ;
6191 bool temp2 = false ;
6192 PyObject * obj0 = 0 ;
6193 PyObject * obj1 = 0 ;
6194 char *kwnames[] = {
6195 (char *) "self",(char *) "tip", NULL
6196 };
6197
6198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6200 if (SWIG_arg_fail(1)) SWIG_fail;
6201 {
6202 arg2 = wxString_in_helper(obj1);
6203 if (arg2 == NULL) SWIG_fail;
6204 temp2 = true;
6205 }
6206 {
6207 PyThreadState* __tstate = wxPyBeginAllowThreads();
6208 (arg1)->SetTip((wxString const &)*arg2);
6209
6210 wxPyEndAllowThreads(__tstate);
6211 if (PyErr_Occurred()) SWIG_fail;
6212 }
6213 Py_INCREF(Py_None); resultobj = Py_None;
6214 {
6215 if (temp2)
6216 delete arg2;
6217 }
6218 return resultobj;
6219 fail:
6220 {
6221 if (temp2)
6222 delete arg2;
6223 }
6224 return NULL;
6225 }
6226
6227
6228 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj;
6230 wxToolTip *arg1 = (wxToolTip *) 0 ;
6231 wxString result;
6232 PyObject * obj0 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "self", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 {
6241 PyThreadState* __tstate = wxPyBeginAllowThreads();
6242 result = (arg1)->GetTip();
6243
6244 wxPyEndAllowThreads(__tstate);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 {
6248 #if wxUSE_UNICODE
6249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6250 #else
6251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6252 #endif
6253 }
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj;
6262 wxToolTip *arg1 = (wxToolTip *) 0 ;
6263 wxWindow *result;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "self", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6271 if (SWIG_arg_fail(1)) SWIG_fail;
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (wxWindow *)(arg1)->GetWindow();
6275
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 {
6280 resultobj = wxPyMake_wxObject(result, 0);
6281 }
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 bool arg1 ;
6291 PyObject * obj0 = 0 ;
6292 char *kwnames[] = {
6293 (char *) "flag", NULL
6294 };
6295
6296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6297 {
6298 arg1 = (bool)(SWIG_As_bool(obj0));
6299 if (SWIG_arg_fail(1)) SWIG_fail;
6300 }
6301 {
6302 PyThreadState* __tstate = wxPyBeginAllowThreads();
6303 wxToolTip::Enable(arg1);
6304
6305 wxPyEndAllowThreads(__tstate);
6306 if (PyErr_Occurred()) SWIG_fail;
6307 }
6308 Py_INCREF(Py_None); resultobj = Py_None;
6309 return resultobj;
6310 fail:
6311 return NULL;
6312 }
6313
6314
6315 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6316 PyObject *resultobj;
6317 long arg1 ;
6318 PyObject * obj0 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "milliseconds", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6324 {
6325 arg1 = (long)(SWIG_As_long(obj0));
6326 if (SWIG_arg_fail(1)) SWIG_fail;
6327 }
6328 {
6329 PyThreadState* __tstate = wxPyBeginAllowThreads();
6330 wxToolTip::SetDelay(arg1);
6331
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 Py_INCREF(Py_None); resultobj = Py_None;
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6343 PyObject *obj;
6344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6345 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6346 Py_INCREF(obj);
6347 return Py_BuildValue((char *)"");
6348 }
6349 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6350 PyObject *resultobj;
6351 wxWindow *arg1 = (wxWindow *) 0 ;
6352 wxSize *arg2 = 0 ;
6353 wxCaret *result;
6354 wxSize temp2 ;
6355 PyObject * obj0 = 0 ;
6356 PyObject * obj1 = 0 ;
6357 char *kwnames[] = {
6358 (char *) "window",(char *) "size", NULL
6359 };
6360
6361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6363 if (SWIG_arg_fail(1)) SWIG_fail;
6364 {
6365 arg2 = &temp2;
6366 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6367 }
6368 {
6369 if (!wxPyCheckForApp()) SWIG_fail;
6370 PyThreadState* __tstate = wxPyBeginAllowThreads();
6371 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6372
6373 wxPyEndAllowThreads(__tstate);
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6384 PyObject *resultobj;
6385 wxCaret *arg1 = (wxCaret *) 0 ;
6386 PyObject * obj0 = 0 ;
6387 char *kwnames[] = {
6388 (char *) "self", NULL
6389 };
6390
6391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6393 if (SWIG_arg_fail(1)) SWIG_fail;
6394 {
6395 PyThreadState* __tstate = wxPyBeginAllowThreads();
6396 wxCaret_Destroy(arg1);
6397
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 Py_INCREF(Py_None); resultobj = Py_None;
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6409 PyObject *resultobj;
6410 wxCaret *arg1 = (wxCaret *) 0 ;
6411 bool result;
6412 PyObject * obj0 = 0 ;
6413 char *kwnames[] = {
6414 (char *) "self", NULL
6415 };
6416
6417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(1)) SWIG_fail;
6420 {
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (bool)(arg1)->IsOk();
6423
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 {
6428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6429 }
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj;
6438 wxCaret *arg1 = (wxCaret *) 0 ;
6439 bool result;
6440 PyObject * obj0 = 0 ;
6441 char *kwnames[] = {
6442 (char *) "self", NULL
6443 };
6444
6445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6447 if (SWIG_arg_fail(1)) SWIG_fail;
6448 {
6449 PyThreadState* __tstate = wxPyBeginAllowThreads();
6450 result = (bool)(arg1)->IsVisible();
6451
6452 wxPyEndAllowThreads(__tstate);
6453 if (PyErr_Occurred()) SWIG_fail;
6454 }
6455 {
6456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6457 }
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj;
6466 wxCaret *arg1 = (wxCaret *) 0 ;
6467 wxPoint result;
6468 PyObject * obj0 = 0 ;
6469 char *kwnames[] = {
6470 (char *) "self", NULL
6471 };
6472
6473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6475 if (SWIG_arg_fail(1)) SWIG_fail;
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (arg1)->GetPosition();
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 {
6484 wxPoint * resultptr;
6485 resultptr = new wxPoint((wxPoint &)(result));
6486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6487 }
6488 return resultobj;
6489 fail:
6490 return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6495 PyObject *resultobj;
6496 wxCaret *arg1 = (wxCaret *) 0 ;
6497 int *arg2 = (int *) 0 ;
6498 int *arg3 = (int *) 0 ;
6499 int temp2 ;
6500 int res2 = 0 ;
6501 int temp3 ;
6502 int res3 = 0 ;
6503 PyObject * obj0 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self", NULL
6506 };
6507
6508 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6509 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 {
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 (arg1)->GetPosition(arg2,arg3);
6516
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 Py_INCREF(Py_None); resultobj = Py_None;
6521 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6522 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6523 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6524 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj;
6533 wxCaret *arg1 = (wxCaret *) 0 ;
6534 wxSize result;
6535 PyObject * obj0 = 0 ;
6536 char *kwnames[] = {
6537 (char *) "self", NULL
6538 };
6539
6540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6542 if (SWIG_arg_fail(1)) SWIG_fail;
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = (arg1)->GetSize();
6546
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 {
6551 wxSize * resultptr;
6552 resultptr = new wxSize((wxSize &)(result));
6553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6554 }
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj;
6563 wxCaret *arg1 = (wxCaret *) 0 ;
6564 int *arg2 = (int *) 0 ;
6565 int *arg3 = (int *) 0 ;
6566 int temp2 ;
6567 int res2 = 0 ;
6568 int temp3 ;
6569 int res3 = 0 ;
6570 PyObject * obj0 = 0 ;
6571 char *kwnames[] = {
6572 (char *) "self", NULL
6573 };
6574
6575 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6576 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->GetSize(arg2,arg3);
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 Py_INCREF(Py_None); resultobj = Py_None;
6588 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6589 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxCaret *arg1 = (wxCaret *) 0 ;
6601 wxWindow *result;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6609 if (SWIG_arg_fail(1)) SWIG_fail;
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = (wxWindow *)(arg1)->GetWindow();
6613
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 {
6618 resultobj = wxPyMake_wxObject(result, 0);
6619 }
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6627 PyObject *resultobj;
6628 wxCaret *arg1 = (wxCaret *) 0 ;
6629 int arg2 ;
6630 int arg3 ;
6631 PyObject * obj0 = 0 ;
6632 PyObject * obj1 = 0 ;
6633 PyObject * obj2 = 0 ;
6634 char *kwnames[] = {
6635 (char *) "self",(char *) "x",(char *) "y", NULL
6636 };
6637
6638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(1)) SWIG_fail;
6641 {
6642 arg2 = (int)(SWIG_As_int(obj1));
6643 if (SWIG_arg_fail(2)) SWIG_fail;
6644 }
6645 {
6646 arg3 = (int)(SWIG_As_int(obj2));
6647 if (SWIG_arg_fail(3)) SWIG_fail;
6648 }
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 (arg1)->Move(arg2,arg3);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 Py_INCREF(Py_None); resultobj = Py_None;
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj;
6665 wxCaret *arg1 = (wxCaret *) 0 ;
6666 wxPoint *arg2 = 0 ;
6667 wxPoint temp2 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 char *kwnames[] = {
6671 (char *) "self",(char *) "pt", NULL
6672 };
6673
6674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6676 if (SWIG_arg_fail(1)) SWIG_fail;
6677 {
6678 arg2 = &temp2;
6679 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6680 }
6681 {
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 (arg1)->Move((wxPoint const &)*arg2);
6684
6685 wxPyEndAllowThreads(__tstate);
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 Py_INCREF(Py_None); resultobj = Py_None;
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6696 PyObject *resultobj;
6697 wxCaret *arg1 = (wxCaret *) 0 ;
6698 int arg2 ;
6699 int arg3 ;
6700 PyObject * obj0 = 0 ;
6701 PyObject * obj1 = 0 ;
6702 PyObject * obj2 = 0 ;
6703 char *kwnames[] = {
6704 (char *) "self",(char *) "width",(char *) "height", NULL
6705 };
6706
6707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6709 if (SWIG_arg_fail(1)) SWIG_fail;
6710 {
6711 arg2 = (int)(SWIG_As_int(obj1));
6712 if (SWIG_arg_fail(2)) SWIG_fail;
6713 }
6714 {
6715 arg3 = (int)(SWIG_As_int(obj2));
6716 if (SWIG_arg_fail(3)) SWIG_fail;
6717 }
6718 {
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 (arg1)->SetSize(arg2,arg3);
6721
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 Py_INCREF(Py_None); resultobj = Py_None;
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6733 PyObject *resultobj;
6734 wxCaret *arg1 = (wxCaret *) 0 ;
6735 wxSize *arg2 = 0 ;
6736 wxSize temp2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self",(char *) "size", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetSize((wxSize const &)*arg2);
6753
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 Py_INCREF(Py_None); resultobj = Py_None;
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxCaret *arg1 = (wxCaret *) 0 ;
6767 int arg2 = (int) true ;
6768 PyObject * obj0 = 0 ;
6769 PyObject * obj1 = 0 ;
6770 char *kwnames[] = {
6771 (char *) "self",(char *) "show", NULL
6772 };
6773
6774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6776 if (SWIG_arg_fail(1)) SWIG_fail;
6777 if (obj1) {
6778 {
6779 arg2 = (int)(SWIG_As_int(obj1));
6780 if (SWIG_arg_fail(2)) SWIG_fail;
6781 }
6782 }
6783 {
6784 PyThreadState* __tstate = wxPyBeginAllowThreads();
6785 (arg1)->Show(arg2);
6786
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 Py_INCREF(Py_None); resultobj = Py_None;
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6798 PyObject *resultobj;
6799 wxCaret *arg1 = (wxCaret *) 0 ;
6800 PyObject * obj0 = 0 ;
6801 char *kwnames[] = {
6802 (char *) "self", NULL
6803 };
6804
6805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6807 if (SWIG_arg_fail(1)) SWIG_fail;
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 (arg1)->Hide();
6811
6812 wxPyEndAllowThreads(__tstate);
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 Py_INCREF(Py_None); resultobj = Py_None;
6816 return resultobj;
6817 fail:
6818 return NULL;
6819 }
6820
6821
6822 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj;
6824 int result;
6825 char *kwnames[] = {
6826 NULL
6827 };
6828
6829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6830 {
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 result = (int)wxCaret::GetBlinkTime();
6833
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 resultobj = SWIG_From_int((int)(result));
6839 }
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj;
6848 int arg1 ;
6849 PyObject * obj0 = 0 ;
6850 char *kwnames[] = {
6851 (char *) "milliseconds", NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6855 {
6856 arg1 = (int)(SWIG_As_int(obj0));
6857 if (SWIG_arg_fail(1)) SWIG_fail;
6858 }
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 wxCaret::SetBlinkTime(arg1);
6862
6863 wxPyEndAllowThreads(__tstate);
6864 if (PyErr_Occurred()) SWIG_fail;
6865 }
6866 Py_INCREF(Py_None); resultobj = Py_None;
6867 return resultobj;
6868 fail:
6869 return NULL;
6870 }
6871
6872
6873 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6874 PyObject *obj;
6875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6876 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6877 Py_INCREF(obj);
6878 return Py_BuildValue((char *)"");
6879 }
6880 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6883 wxBusyCursor *result;
6884 PyObject * obj0 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "cursor", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6890 if (obj0) {
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 }
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6898
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6910 PyObject *resultobj;
6911 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6912 PyObject * obj0 = 0 ;
6913 char *kwnames[] = {
6914 (char *) "self", NULL
6915 };
6916
6917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(1)) SWIG_fail;
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 delete arg1;
6923
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 Py_INCREF(Py_None); resultobj = Py_None;
6928 return resultobj;
6929 fail:
6930 return NULL;
6931 }
6932
6933
6934 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6935 PyObject *obj;
6936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6937 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6938 Py_INCREF(obj);
6939 return Py_BuildValue((char *)"");
6940 }
6941 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6942 PyObject *resultobj;
6943 wxWindow *arg1 = (wxWindow *) NULL ;
6944 wxWindowDisabler *result;
6945 PyObject * obj0 = 0 ;
6946 char *kwnames[] = {
6947 (char *) "winToSkip", NULL
6948 };
6949
6950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6951 if (obj0) {
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 }
6955 {
6956 if (!wxPyCheckForApp()) SWIG_fail;
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6959
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6971 PyObject *resultobj;
6972 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6973 PyObject * obj0 = 0 ;
6974 char *kwnames[] = {
6975 (char *) "self", NULL
6976 };
6977
6978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6980 if (SWIG_arg_fail(1)) SWIG_fail;
6981 {
6982 PyThreadState* __tstate = wxPyBeginAllowThreads();
6983 delete arg1;
6984
6985 wxPyEndAllowThreads(__tstate);
6986 if (PyErr_Occurred()) SWIG_fail;
6987 }
6988 Py_INCREF(Py_None); resultobj = Py_None;
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6996 PyObject *obj;
6997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6998 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6999 Py_INCREF(obj);
7000 return Py_BuildValue((char *)"");
7001 }
7002 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7003 PyObject *resultobj;
7004 wxString *arg1 = 0 ;
7005 wxBusyInfo *result;
7006 bool temp1 = false ;
7007 PyObject * obj0 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "message", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7013 {
7014 arg1 = wxString_in_helper(obj0);
7015 if (arg1 == NULL) SWIG_fail;
7016 temp1 = true;
7017 }
7018 {
7019 if (!wxPyCheckForApp()) SWIG_fail;
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7027 {
7028 if (temp1)
7029 delete arg1;
7030 }
7031 return resultobj;
7032 fail:
7033 {
7034 if (temp1)
7035 delete arg1;
7036 }
7037 return NULL;
7038 }
7039
7040
7041 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj;
7043 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7044 PyObject * obj0 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 delete arg1;
7055
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 Py_INCREF(Py_None); resultobj = Py_None;
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7067 PyObject *obj;
7068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7069 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7070 Py_INCREF(obj);
7071 return Py_BuildValue((char *)"");
7072 }
7073 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxStopWatch *result;
7076 char *kwnames[] = {
7077 NULL
7078 };
7079
7080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7081 {
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (wxStopWatch *)new wxStopWatch();
7084
7085 wxPyEndAllowThreads(__tstate);
7086 if (PyErr_Occurred()) SWIG_fail;
7087 }
7088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7098 long arg2 = (long) 0 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "self",(char *) "t0", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7107 if (SWIG_arg_fail(1)) SWIG_fail;
7108 if (obj1) {
7109 {
7110 arg2 = (long)(SWIG_As_long(obj1));
7111 if (SWIG_arg_fail(2)) SWIG_fail;
7112 }
7113 }
7114 {
7115 PyThreadState* __tstate = wxPyBeginAllowThreads();
7116 (arg1)->Start(arg2);
7117
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 Py_INCREF(Py_None); resultobj = Py_None;
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj;
7130 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7131 PyObject * obj0 = 0 ;
7132 char *kwnames[] = {
7133 (char *) "self", NULL
7134 };
7135
7136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7138 if (SWIG_arg_fail(1)) SWIG_fail;
7139 {
7140 PyThreadState* __tstate = wxPyBeginAllowThreads();
7141 (arg1)->Pause();
7142
7143 wxPyEndAllowThreads(__tstate);
7144 if (PyErr_Occurred()) SWIG_fail;
7145 }
7146 Py_INCREF(Py_None); resultobj = Py_None;
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj;
7155 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7156 PyObject * obj0 = 0 ;
7157 char *kwnames[] = {
7158 (char *) "self", NULL
7159 };
7160
7161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7163 if (SWIG_arg_fail(1)) SWIG_fail;
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 (arg1)->Resume();
7167
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 Py_INCREF(Py_None); resultobj = Py_None;
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj;
7180 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7181 long result;
7182 PyObject * obj0 = 0 ;
7183 char *kwnames[] = {
7184 (char *) "self", NULL
7185 };
7186
7187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7189 if (SWIG_arg_fail(1)) SWIG_fail;
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 result = (long)((wxStopWatch const *)arg1)->Time();
7193
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 {
7198 resultobj = SWIG_From_long((long)(result));
7199 }
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7207 PyObject *obj;
7208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7209 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7210 Py_INCREF(obj);
7211 return Py_BuildValue((char *)"");
7212 }
7213 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7214 PyObject *resultobj;
7215 int arg1 = (int) 9 ;
7216 int arg2 = (int) wxID_FILE1 ;
7217 wxFileHistory *result;
7218 PyObject * obj0 = 0 ;
7219 PyObject * obj1 = 0 ;
7220 char *kwnames[] = {
7221 (char *) "maxFiles",(char *) "idBase", NULL
7222 };
7223
7224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7225 if (obj0) {
7226 {
7227 arg1 = (int)(SWIG_As_int(obj0));
7228 if (SWIG_arg_fail(1)) SWIG_fail;
7229 }
7230 }
7231 if (obj1) {
7232 {
7233 arg2 = (int)(SWIG_As_int(obj1));
7234 if (SWIG_arg_fail(2)) SWIG_fail;
7235 }
7236 }
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7254 PyObject * obj0 = 0 ;
7255 char *kwnames[] = {
7256 (char *) "self", NULL
7257 };
7258
7259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7261 if (SWIG_arg_fail(1)) SWIG_fail;
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 delete arg1;
7265
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 Py_INCREF(Py_None); resultobj = Py_None;
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj;
7278 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7279 wxString *arg2 = 0 ;
7280 bool temp2 = false ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char *kwnames[] = {
7284 (char *) "self",(char *) "file", NULL
7285 };
7286
7287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7289 if (SWIG_arg_fail(1)) SWIG_fail;
7290 {
7291 arg2 = wxString_in_helper(obj1);
7292 if (arg2 == NULL) SWIG_fail;
7293 temp2 = true;
7294 }
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 (arg1)->AddFileToHistory((wxString const &)*arg2);
7298
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 Py_INCREF(Py_None); resultobj = Py_None;
7303 {
7304 if (temp2)
7305 delete arg2;
7306 }
7307 return resultobj;
7308 fail:
7309 {
7310 if (temp2)
7311 delete arg2;
7312 }
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7320 int arg2 ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self",(char *) "i", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 arg2 = (int)(SWIG_As_int(obj1));
7332 if (SWIG_arg_fail(2)) SWIG_fail;
7333 }
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 (arg1)->RemoveFileFromHistory(arg2);
7337
7338 wxPyEndAllowThreads(__tstate);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 Py_INCREF(Py_None); resultobj = Py_None;
7342 return resultobj;
7343 fail:
7344 return NULL;
7345 }
7346
7347
7348 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7349 PyObject *resultobj;
7350 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7351 int result;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 {
7368 resultobj = SWIG_From_int((int)(result));
7369 }
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7377 PyObject *resultobj;
7378 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7379 wxMenu *arg2 = (wxMenu *) 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 char *kwnames[] = {
7383 (char *) "self",(char *) "menu", NULL
7384 };
7385
7386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7388 if (SWIG_arg_fail(1)) SWIG_fail;
7389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(2)) SWIG_fail;
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 (arg1)->UseMenu(arg2);
7394
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 Py_INCREF(Py_None); resultobj = Py_None;
7399 return resultobj;
7400 fail:
7401 return NULL;
7402 }
7403
7404
7405 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7406 PyObject *resultobj;
7407 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7408 wxMenu *arg2 = (wxMenu *) 0 ;
7409 PyObject * obj0 = 0 ;
7410 PyObject * obj1 = 0 ;
7411 char *kwnames[] = {
7412 (char *) "self",(char *) "menu", NULL
7413 };
7414
7415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7417 if (SWIG_arg_fail(1)) SWIG_fail;
7418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(2)) SWIG_fail;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->RemoveMenu(arg2);
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 Py_INCREF(Py_None); resultobj = Py_None;
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7437 wxConfigBase *arg2 = 0 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 char *kwnames[] = {
7441 (char *) "self",(char *) "config", NULL
7442 };
7443
7444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7446 if (SWIG_arg_fail(1)) SWIG_fail;
7447 {
7448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7449 if (SWIG_arg_fail(2)) SWIG_fail;
7450 if (arg2 == NULL) {
7451 SWIG_null_ref("wxConfigBase");
7452 }
7453 if (SWIG_arg_fail(2)) SWIG_fail;
7454 }
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->Load(*arg2);
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7472 wxConfigBase *arg2 = 0 ;
7473 PyObject * obj0 = 0 ;
7474 PyObject * obj1 = 0 ;
7475 char *kwnames[] = {
7476 (char *) "self",(char *) "config", NULL
7477 };
7478
7479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7481 if (SWIG_arg_fail(1)) SWIG_fail;
7482 {
7483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7484 if (SWIG_arg_fail(2)) SWIG_fail;
7485 if (arg2 == NULL) {
7486 SWIG_null_ref("wxConfigBase");
7487 }
7488 if (SWIG_arg_fail(2)) SWIG_fail;
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 (arg1)->Save(*arg2);
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 Py_INCREF(Py_None); resultobj = Py_None;
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj;
7506 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7507 PyObject * obj0 = 0 ;
7508 char *kwnames[] = {
7509 (char *) "self", NULL
7510 };
7511
7512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7514 if (SWIG_arg_fail(1)) SWIG_fail;
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 (arg1)->AddFilesToMenu();
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 Py_INCREF(Py_None); resultobj = Py_None;
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj;
7531 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7532 wxMenu *arg2 = (wxMenu *) 0 ;
7533 PyObject * obj0 = 0 ;
7534 PyObject * obj1 = 0 ;
7535 char *kwnames[] = {
7536 (char *) "self",(char *) "menu", NULL
7537 };
7538
7539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7541 if (SWIG_arg_fail(1)) SWIG_fail;
7542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(2)) SWIG_fail;
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 (arg1)->AddFilesToMenu(arg2);
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 Py_INCREF(Py_None); resultobj = Py_None;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7561 int arg2 ;
7562 wxString result;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char *kwnames[] = {
7566 (char *) "self",(char *) "i", NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7571 if (SWIG_arg_fail(1)) SWIG_fail;
7572 {
7573 arg2 = (int)(SWIG_As_int(obj1));
7574 if (SWIG_arg_fail(2)) SWIG_fail;
7575 }
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 #if wxUSE_UNICODE
7585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7586 #else
7587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7588 #endif
7589 }
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj;
7598 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7599 int result;
7600 PyObject * obj0 = 0 ;
7601 char *kwnames[] = {
7602 (char *) "self", NULL
7603 };
7604
7605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7607 if (SWIG_arg_fail(1)) SWIG_fail;
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (int)((wxFileHistory const *)arg1)->GetCount();
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = SWIG_From_int((int)(result));
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7625 PyObject *obj;
7626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7627 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7628 Py_INCREF(obj);
7629 return Py_BuildValue((char *)"");
7630 }
7631 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj;
7633 wxString *arg1 = 0 ;
7634 wxString const &arg2_defvalue = wxPyEmptyString ;
7635 wxString *arg2 = (wxString *) &arg2_defvalue ;
7636 wxSingleInstanceChecker *result;
7637 bool temp1 = false ;
7638 bool temp2 = false ;
7639 PyObject * obj0 = 0 ;
7640 PyObject * obj1 = 0 ;
7641 char *kwnames[] = {
7642 (char *) "name",(char *) "path", NULL
7643 };
7644
7645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7646 {
7647 arg1 = wxString_in_helper(obj0);
7648 if (arg1 == NULL) SWIG_fail;
7649 temp1 = true;
7650 }
7651 if (obj1) {
7652 {
7653 arg2 = wxString_in_helper(obj1);
7654 if (arg2 == NULL) SWIG_fail;
7655 temp2 = true;
7656 }
7657 }
7658 {
7659 PyThreadState* __tstate = wxPyBeginAllowThreads();
7660 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7661
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7666 {
7667 if (temp1)
7668 delete arg1;
7669 }
7670 {
7671 if (temp2)
7672 delete arg2;
7673 }
7674 return resultobj;
7675 fail:
7676 {
7677 if (temp1)
7678 delete arg1;
7679 }
7680 {
7681 if (temp2)
7682 delete arg2;
7683 }
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxSingleInstanceChecker *result;
7691 char *kwnames[] = {
7692 NULL
7693 };
7694
7695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7699
7700 wxPyEndAllowThreads(__tstate);
7701 if (PyErr_Occurred()) SWIG_fail;
7702 }
7703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj;
7712 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7713 PyObject * obj0 = 0 ;
7714 char *kwnames[] = {
7715 (char *) "self", NULL
7716 };
7717
7718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7720 if (SWIG_arg_fail(1)) SWIG_fail;
7721 {
7722 PyThreadState* __tstate = wxPyBeginAllowThreads();
7723 delete arg1;
7724
7725 wxPyEndAllowThreads(__tstate);
7726 if (PyErr_Occurred()) SWIG_fail;
7727 }
7728 Py_INCREF(Py_None); resultobj = Py_None;
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7736 PyObject *resultobj;
7737 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7738 wxString *arg2 = 0 ;
7739 wxString const &arg3_defvalue = wxPyEmptyString ;
7740 wxString *arg3 = (wxString *) &arg3_defvalue ;
7741 bool result;
7742 bool temp2 = false ;
7743 bool temp3 = false ;
7744 PyObject * obj0 = 0 ;
7745 PyObject * obj1 = 0 ;
7746 PyObject * obj2 = 0 ;
7747 char *kwnames[] = {
7748 (char *) "self",(char *) "name",(char *) "path", NULL
7749 };
7750
7751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7753 if (SWIG_arg_fail(1)) SWIG_fail;
7754 {
7755 arg2 = wxString_in_helper(obj1);
7756 if (arg2 == NULL) SWIG_fail;
7757 temp2 = true;
7758 }
7759 if (obj2) {
7760 {
7761 arg3 = wxString_in_helper(obj2);
7762 if (arg3 == NULL) SWIG_fail;
7763 temp3 = true;
7764 }
7765 }
7766 {
7767 PyThreadState* __tstate = wxPyBeginAllowThreads();
7768 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7769
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 {
7774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7775 }
7776 {
7777 if (temp2)
7778 delete arg2;
7779 }
7780 {
7781 if (temp3)
7782 delete arg3;
7783 }
7784 return resultobj;
7785 fail:
7786 {
7787 if (temp2)
7788 delete arg2;
7789 }
7790 {
7791 if (temp3)
7792 delete arg3;
7793 }
7794 return NULL;
7795 }
7796
7797
7798 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7799 PyObject *resultobj;
7800 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7801 bool result;
7802 PyObject * obj0 = 0 ;
7803 char *kwnames[] = {
7804 (char *) "self", NULL
7805 };
7806
7807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7809 if (SWIG_arg_fail(1)) SWIG_fail;
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7813
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 {
7818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7819 }
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7827 PyObject *obj;
7828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7829 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7830 Py_INCREF(obj);
7831 return Py_BuildValue((char *)"");
7832 }
7833 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj;
7835 wxWindow *arg1 = (wxWindow *) 0 ;
7836 wxDC *arg2 = 0 ;
7837 bool result;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 char *kwnames[] = {
7841 (char *) "window",(char *) "dc", NULL
7842 };
7843
7844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 {
7848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7849 if (SWIG_arg_fail(2)) SWIG_fail;
7850 if (arg2 == NULL) {
7851 SWIG_null_ref("wxDC");
7852 }
7853 if (SWIG_arg_fail(2)) SWIG_fail;
7854 }
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 {
7863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7864 }
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7874 PyObject * obj0 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 delete arg1;
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 Py_INCREF(Py_None); resultobj = Py_None;
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj;
7898 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7899 wxString result;
7900 PyObject * obj0 = 0 ;
7901 char *kwnames[] = {
7902 (char *) "self", NULL
7903 };
7904
7905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7907 if (SWIG_arg_fail(1)) SWIG_fail;
7908 {
7909 PyThreadState* __tstate = wxPyBeginAllowThreads();
7910 result = (arg1)->GetTip();
7911
7912 wxPyEndAllowThreads(__tstate);
7913 if (PyErr_Occurred()) SWIG_fail;
7914 }
7915 {
7916 #if wxUSE_UNICODE
7917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7918 #else
7919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7920 #endif
7921 }
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj;
7930 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7931 size_t result;
7932 PyObject * obj0 = 0 ;
7933 char *kwnames[] = {
7934 (char *) "self", NULL
7935 };
7936
7937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7939 if (SWIG_arg_fail(1)) SWIG_fail;
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (size_t)(arg1)->GetCurrentTip();
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7949 }
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj;
7958 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7959 wxString *arg2 = 0 ;
7960 wxString result;
7961 bool temp2 = false ;
7962 PyObject * obj0 = 0 ;
7963 PyObject * obj1 = 0 ;
7964 char *kwnames[] = {
7965 (char *) "self",(char *) "tip", NULL
7966 };
7967
7968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7970 if (SWIG_arg_fail(1)) SWIG_fail;
7971 {
7972 arg2 = wxString_in_helper(obj1);
7973 if (arg2 == NULL) SWIG_fail;
7974 temp2 = true;
7975 }
7976 {
7977 PyThreadState* __tstate = wxPyBeginAllowThreads();
7978 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7979
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 {
7984 #if wxUSE_UNICODE
7985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7986 #else
7987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7988 #endif
7989 }
7990 {
7991 if (temp2)
7992 delete arg2;
7993 }
7994 return resultobj;
7995 fail:
7996 {
7997 if (temp2)
7998 delete arg2;
7999 }
8000 return NULL;
8001 }
8002
8003
8004 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8005 PyObject *obj;
8006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8007 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8008 Py_INCREF(obj);
8009 return Py_BuildValue((char *)"");
8010 }
8011 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj;
8013 size_t arg1 ;
8014 wxPyTipProvider *result;
8015 PyObject * obj0 = 0 ;
8016 char *kwnames[] = {
8017 (char *) "currentTip", NULL
8018 };
8019
8020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8021 {
8022 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8023 if (SWIG_arg_fail(1)) SWIG_fail;
8024 }
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8040 PyObject *resultobj;
8041 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8042 PyObject *arg2 = (PyObject *) 0 ;
8043 PyObject *arg3 = (PyObject *) 0 ;
8044 PyObject * obj0 = 0 ;
8045 PyObject * obj1 = 0 ;
8046 PyObject * obj2 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self",(char *) "self",(char *) "_class", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 arg2 = obj1;
8055 arg3 = obj2;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 (arg1)->_setCallbackInfo(arg2,arg3);
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 Py_INCREF(Py_None); resultobj = Py_None;
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8071 PyObject *obj;
8072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8073 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8074 Py_INCREF(obj);
8075 return Py_BuildValue((char *)"");
8076 }
8077 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8078 PyObject *resultobj;
8079 wxWindow *arg1 = (wxWindow *) 0 ;
8080 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8081 bool arg3 = (bool) true ;
8082 bool result;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 PyObject * obj2 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(2)) SWIG_fail;
8095 if (obj2) {
8096 {
8097 arg3 = (bool)(SWIG_As_bool(obj2));
8098 if (SWIG_arg_fail(3)) SWIG_fail;
8099 }
8100 }
8101 {
8102 if (!wxPyCheckForApp()) SWIG_fail;
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (bool)wxShowTip(arg1,arg2,arg3);
8105
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 {
8110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8111 }
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj;
8120 wxString *arg1 = 0 ;
8121 size_t arg2 ;
8122 wxTipProvider *result;
8123 bool temp1 = false ;
8124 PyObject * obj0 = 0 ;
8125 PyObject * obj1 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "filename",(char *) "currentTip", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8131 {
8132 arg1 = wxString_in_helper(obj0);
8133 if (arg1 == NULL) SWIG_fail;
8134 temp1 = true;
8135 }
8136 {
8137 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8138 if (SWIG_arg_fail(2)) SWIG_fail;
8139 }
8140 {
8141 if (!wxPyCheckForApp()) SWIG_fail;
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8149 {
8150 if (temp1)
8151 delete arg1;
8152 }
8153 return resultobj;
8154 fail:
8155 {
8156 if (temp1)
8157 delete arg1;
8158 }
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8166 int arg2 = (int) -1 ;
8167 wxPyTimer *result;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 char *kwnames[] = {
8171 (char *) "owner",(char *) "id", NULL
8172 };
8173
8174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8175 if (obj0) {
8176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8177 if (SWIG_arg_fail(1)) SWIG_fail;
8178 }
8179 if (obj1) {
8180 {
8181 arg2 = (int)(SWIG_As_int(obj1));
8182 if (SWIG_arg_fail(2)) SWIG_fail;
8183 }
8184 }
8185 {
8186 if (!wxPyCheckForApp()) SWIG_fail;
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8189
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj;
8202 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8203 PyObject * obj0 = 0 ;
8204 char *kwnames[] = {
8205 (char *) "self", NULL
8206 };
8207
8208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(1)) SWIG_fail;
8211 {
8212 PyThreadState* __tstate = wxPyBeginAllowThreads();
8213 delete arg1;
8214
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 Py_INCREF(Py_None); resultobj = Py_None;
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj;
8227 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8228 PyObject *arg2 = (PyObject *) 0 ;
8229 PyObject *arg3 = (PyObject *) 0 ;
8230 int arg4 = (int) 1 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 PyObject * obj2 = 0 ;
8234 PyObject * obj3 = 0 ;
8235 char *kwnames[] = {
8236 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8237 };
8238
8239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8241 if (SWIG_arg_fail(1)) SWIG_fail;
8242 arg2 = obj1;
8243 arg3 = obj2;
8244 if (obj3) {
8245 {
8246 arg4 = (int)(SWIG_As_int(obj3));
8247 if (SWIG_arg_fail(4)) SWIG_fail;
8248 }
8249 }
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 Py_INCREF(Py_None); resultobj = Py_None;
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8267 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8268 int arg3 = (int) -1 ;
8269 PyObject * obj0 = 0 ;
8270 PyObject * obj1 = 0 ;
8271 PyObject * obj2 = 0 ;
8272 char *kwnames[] = {
8273 (char *) "self",(char *) "owner",(char *) "id", NULL
8274 };
8275
8276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8278 if (SWIG_arg_fail(1)) SWIG_fail;
8279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(2)) SWIG_fail;
8281 if (obj2) {
8282 {
8283 arg3 = (int)(SWIG_As_int(obj2));
8284 if (SWIG_arg_fail(3)) SWIG_fail;
8285 }
8286 }
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 (arg1)->SetOwner(arg2,arg3);
8290
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 Py_INCREF(Py_None); resultobj = Py_None;
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj;
8303 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8304 wxEvtHandler *result;
8305 PyObject * obj0 = 0 ;
8306 char *kwnames[] = {
8307 (char *) "self", NULL
8308 };
8309
8310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8312 if (SWIG_arg_fail(1)) SWIG_fail;
8313 {
8314 PyThreadState* __tstate = wxPyBeginAllowThreads();
8315 result = (wxEvtHandler *)(arg1)->GetOwner();
8316
8317 wxPyEndAllowThreads(__tstate);
8318 if (PyErr_Occurred()) SWIG_fail;
8319 }
8320 {
8321 resultobj = wxPyMake_wxObject(result, 0);
8322 }
8323 return resultobj;
8324 fail:
8325 return NULL;
8326 }
8327
8328
8329 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8330 PyObject *resultobj;
8331 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8332 int arg2 = (int) -1 ;
8333 bool arg3 = (bool) false ;
8334 bool result;
8335 PyObject * obj0 = 0 ;
8336 PyObject * obj1 = 0 ;
8337 PyObject * obj2 = 0 ;
8338 char *kwnames[] = {
8339 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8340 };
8341
8342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8344 if (SWIG_arg_fail(1)) SWIG_fail;
8345 if (obj1) {
8346 {
8347 arg2 = (int)(SWIG_As_int(obj1));
8348 if (SWIG_arg_fail(2)) SWIG_fail;
8349 }
8350 }
8351 if (obj2) {
8352 {
8353 arg3 = (bool)(SWIG_As_bool(obj2));
8354 if (SWIG_arg_fail(3)) SWIG_fail;
8355 }
8356 }
8357 {
8358 PyThreadState* __tstate = wxPyBeginAllowThreads();
8359 result = (bool)(arg1)->Start(arg2,arg3);
8360
8361 wxPyEndAllowThreads(__tstate);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 {
8365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8366 }
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj;
8375 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8376 PyObject * obj0 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 (arg1)->Stop();
8387
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 Py_INCREF(Py_None); resultobj = Py_None;
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj;
8400 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8401 bool result;
8402 PyObject * obj0 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 {
8418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8419 }
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8427 PyObject *resultobj;
8428 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8429 int result;
8430 PyObject * obj0 = 0 ;
8431 char *kwnames[] = {
8432 (char *) "self", NULL
8433 };
8434
8435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8441
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = SWIG_From_int((int)(result));
8447 }
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8457 bool result;
8458 PyObject * obj0 = 0 ;
8459 char *kwnames[] = {
8460 (char *) "self", NULL
8461 };
8462
8463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8465 if (SWIG_arg_fail(1)) SWIG_fail;
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 {
8474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8475 }
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8485 int result;
8486 PyObject * obj0 = 0 ;
8487 char *kwnames[] = {
8488 (char *) "self", NULL
8489 };
8490
8491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8493 if (SWIG_arg_fail(1)) SWIG_fail;
8494 {
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 result = (int)((wxPyTimer const *)arg1)->GetId();
8497
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 {
8502 resultobj = SWIG_From_int((int)(result));
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8511 PyObject *obj;
8512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8513 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8514 Py_INCREF(obj);
8515 return Py_BuildValue((char *)"");
8516 }
8517 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8518 PyObject *resultobj;
8519 int arg1 = (int) 0 ;
8520 int arg2 = (int) 0 ;
8521 wxTimerEvent *result;
8522 PyObject * obj0 = 0 ;
8523 PyObject * obj1 = 0 ;
8524 char *kwnames[] = {
8525 (char *) "timerid",(char *) "interval", NULL
8526 };
8527
8528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8529 if (obj0) {
8530 {
8531 arg1 = (int)(SWIG_As_int(obj0));
8532 if (SWIG_arg_fail(1)) SWIG_fail;
8533 }
8534 }
8535 if (obj1) {
8536 {
8537 arg2 = (int)(SWIG_As_int(obj1));
8538 if (SWIG_arg_fail(2)) SWIG_fail;
8539 }
8540 }
8541 {
8542 PyThreadState* __tstate = wxPyBeginAllowThreads();
8543 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8544
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8558 int result;
8559 PyObject * obj0 = 0 ;
8560 char *kwnames[] = {
8561 (char *) "self", NULL
8562 };
8563
8564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8566 if (SWIG_arg_fail(1)) SWIG_fail;
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8570
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 {
8575 resultobj = SWIG_From_int((int)(result));
8576 }
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8584 PyObject *obj;
8585 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8586 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8587 Py_INCREF(obj);
8588 return Py_BuildValue((char *)"");
8589 }
8590 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8591 PyObject *resultobj;
8592 wxTimer *arg1 = 0 ;
8593 wxTimerRunner *result;
8594 PyObject * obj0 = 0 ;
8595
8596 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8597 {
8598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8599 if (SWIG_arg_fail(1)) SWIG_fail;
8600 if (arg1 == NULL) {
8601 SWIG_null_ref("wxTimer");
8602 }
8603 if (SWIG_arg_fail(1)) SWIG_fail;
8604 }
8605 {
8606 if (!wxPyCheckForApp()) SWIG_fail;
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8621 PyObject *resultobj;
8622 wxTimer *arg1 = 0 ;
8623 int arg2 ;
8624 bool arg3 = (bool) false ;
8625 wxTimerRunner *result;
8626 PyObject * obj0 = 0 ;
8627 PyObject * obj1 = 0 ;
8628 PyObject * obj2 = 0 ;
8629
8630 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8631 {
8632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8633 if (SWIG_arg_fail(1)) SWIG_fail;
8634 if (arg1 == NULL) {
8635 SWIG_null_ref("wxTimer");
8636 }
8637 if (SWIG_arg_fail(1)) SWIG_fail;
8638 }
8639 {
8640 arg2 = (int)(SWIG_As_int(obj1));
8641 if (SWIG_arg_fail(2)) SWIG_fail;
8642 }
8643 if (obj2) {
8644 {
8645 arg3 = (bool)(SWIG_As_bool(obj2));
8646 if (SWIG_arg_fail(3)) SWIG_fail;
8647 }
8648 }
8649 {
8650 if (!wxPyCheckForApp()) SWIG_fail;
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8658 return resultobj;
8659 fail:
8660 return NULL;
8661 }
8662
8663
8664 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8665 int argc;
8666 PyObject *argv[4];
8667 int ii;
8668
8669 argc = PyObject_Length(args);
8670 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8671 argv[ii] = PyTuple_GetItem(args,ii);
8672 }
8673 if (argc == 1) {
8674 int _v;
8675 {
8676 void *ptr = 0;
8677 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8678 _v = 0;
8679 PyErr_Clear();
8680 } else {
8681 _v = (ptr != 0);
8682 }
8683 }
8684 if (_v) {
8685 return _wrap_new_TimerRunner__SWIG_0(self,args);
8686 }
8687 }
8688 if ((argc >= 2) && (argc <= 3)) {
8689 int _v;
8690 {
8691 void *ptr = 0;
8692 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8693 _v = 0;
8694 PyErr_Clear();
8695 } else {
8696 _v = (ptr != 0);
8697 }
8698 }
8699 if (_v) {
8700 _v = SWIG_Check_int(argv[1]);
8701 if (_v) {
8702 if (argc <= 2) {
8703 return _wrap_new_TimerRunner__SWIG_1(self,args);
8704 }
8705 _v = SWIG_Check_bool(argv[2]);
8706 if (_v) {
8707 return _wrap_new_TimerRunner__SWIG_1(self,args);
8708 }
8709 }
8710 }
8711 }
8712
8713 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8721 PyObject * obj0 = 0 ;
8722 char *kwnames[] = {
8723 (char *) "self", NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 delete arg1;
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 Py_INCREF(Py_None); resultobj = Py_None;
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj;
8745 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8746 int arg2 ;
8747 bool arg3 = (bool) false ;
8748 PyObject * obj0 = 0 ;
8749 PyObject * obj1 = 0 ;
8750 PyObject * obj2 = 0 ;
8751 char *kwnames[] = {
8752 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8753 };
8754
8755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8757 if (SWIG_arg_fail(1)) SWIG_fail;
8758 {
8759 arg2 = (int)(SWIG_As_int(obj1));
8760 if (SWIG_arg_fail(2)) SWIG_fail;
8761 }
8762 if (obj2) {
8763 {
8764 arg3 = (bool)(SWIG_As_bool(obj2));
8765 if (SWIG_arg_fail(3)) SWIG_fail;
8766 }
8767 }
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 (arg1)->Start(arg2,arg3);
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8783 PyObject *obj;
8784 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8785 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8786 Py_INCREF(obj);
8787 return Py_BuildValue((char *)"");
8788 }
8789 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj;
8791 wxLog *result;
8792 char *kwnames[] = {
8793 NULL
8794 };
8795
8796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8797 {
8798 PyThreadState* __tstate = wxPyBeginAllowThreads();
8799 result = (wxLog *)new wxLog();
8800
8801 wxPyEndAllowThreads(__tstate);
8802 if (PyErr_Occurred()) SWIG_fail;
8803 }
8804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8805 return resultobj;
8806 fail:
8807 return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj;
8813 bool result;
8814 char *kwnames[] = {
8815 NULL
8816 };
8817
8818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 result = (bool)wxLog::IsEnabled();
8822
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 {
8827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8828 }
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 bool arg1 = (bool) true ;
8838 bool result;
8839 PyObject * obj0 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "doIt", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8845 if (obj0) {
8846 {
8847 arg1 = (bool)(SWIG_As_bool(obj0));
8848 if (SWIG_arg_fail(1)) SWIG_fail;
8849 }
8850 }
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 result = (bool)wxLog::EnableLogging(arg1);
8854
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 {
8859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8860 }
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxLogLevel arg1 ;
8870 wxChar *arg2 = (wxChar *) 0 ;
8871 time_t arg3 ;
8872 PyObject * obj0 = 0 ;
8873 PyObject * obj1 = 0 ;
8874 PyObject * obj2 = 0 ;
8875 char *kwnames[] = {
8876 (char *) "level",(char *) "szString",(char *) "t", NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8880 {
8881 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8882 if (SWIG_arg_fail(1)) SWIG_fail;
8883 }
8884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8885 if (SWIG_arg_fail(2)) SWIG_fail;
8886 {
8887 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8888 if (SWIG_arg_fail(3)) SWIG_fail;
8889 }
8890 {
8891 PyThreadState* __tstate = wxPyBeginAllowThreads();
8892 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8893
8894 wxPyEndAllowThreads(__tstate);
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 Py_INCREF(Py_None); resultobj = Py_None;
8898 return resultobj;
8899 fail:
8900 return NULL;
8901 }
8902
8903
8904 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj;
8906 wxLog *arg1 = (wxLog *) 0 ;
8907 PyObject * obj0 = 0 ;
8908 char *kwnames[] = {
8909 (char *) "self", NULL
8910 };
8911
8912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8914 if (SWIG_arg_fail(1)) SWIG_fail;
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 (arg1)->Flush();
8918
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 Py_INCREF(Py_None); resultobj = Py_None;
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8930 PyObject *resultobj;
8931 char *kwnames[] = {
8932 NULL
8933 };
8934
8935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 wxLog::FlushActive();
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 Py_INCREF(Py_None); resultobj = Py_None;
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8951 PyObject *resultobj;
8952 wxLog *result;
8953 char *kwnames[] = {
8954 NULL
8955 };
8956
8957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 result = (wxLog *)wxLog::GetActiveTarget();
8961
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 wxLog *arg1 = (wxLog *) 0 ;
8975 wxLog *result;
8976 PyObject * obj0 = 0 ;
8977 char *kwnames[] = {
8978 (char *) "pLogger", NULL
8979 };
8980
8981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8983 if (SWIG_arg_fail(1)) SWIG_fail;
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8987
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj;
9000 char *kwnames[] = {
9001 NULL
9002 };
9003
9004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 wxLog::Suspend();
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 Py_INCREF(Py_None); resultobj = Py_None;
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj;
9021 char *kwnames[] = {
9022 NULL
9023 };
9024
9025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9026 {
9027 PyThreadState* __tstate = wxPyBeginAllowThreads();
9028 wxLog::Resume();
9029
9030 wxPyEndAllowThreads(__tstate);
9031 if (PyErr_Occurred()) SWIG_fail;
9032 }
9033 Py_INCREF(Py_None); resultobj = Py_None;
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9041 PyObject *resultobj;
9042 bool arg1 = (bool) true ;
9043 PyObject * obj0 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "bVerbose", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9049 if (obj0) {
9050 {
9051 arg1 = (bool)(SWIG_As_bool(obj0));
9052 if (SWIG_arg_fail(1)) SWIG_fail;
9053 }
9054 }
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 wxLog::SetVerbose(arg1);
9058
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 Py_INCREF(Py_None); resultobj = Py_None;
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj;
9071 wxLogLevel arg1 ;
9072 PyObject * obj0 = 0 ;
9073 char *kwnames[] = {
9074 (char *) "logLevel", NULL
9075 };
9076
9077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9078 {
9079 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9080 if (SWIG_arg_fail(1)) SWIG_fail;
9081 }
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 wxLog::SetLogLevel(arg1);
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 Py_INCREF(Py_None); resultobj = Py_None;
9090 return resultobj;
9091 fail:
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 char *kwnames[] = {
9099 NULL
9100 };
9101
9102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 wxLog::DontCreateOnDemand();
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_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj;
9119 wxTraceMask arg1 ;
9120 PyObject * obj0 = 0 ;
9121 char *kwnames[] = {
9122 (char *) "ulMask", NULL
9123 };
9124
9125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9126 {
9127 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 wxLog::SetTraceMask(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_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj;
9146 wxString *arg1 = 0 ;
9147 bool temp1 = false ;
9148 PyObject * obj0 = 0 ;
9149 char *kwnames[] = {
9150 (char *) "str", NULL
9151 };
9152
9153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9154 {
9155 arg1 = wxString_in_helper(obj0);
9156 if (arg1 == NULL) SWIG_fail;
9157 temp1 = true;
9158 }
9159 {
9160 PyThreadState* __tstate = wxPyBeginAllowThreads();
9161 wxLog::AddTraceMask((wxString const &)*arg1);
9162
9163 wxPyEndAllowThreads(__tstate);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 Py_INCREF(Py_None); resultobj = Py_None;
9167 {
9168 if (temp1)
9169 delete arg1;
9170 }
9171 return resultobj;
9172 fail:
9173 {
9174 if (temp1)
9175 delete arg1;
9176 }
9177 return NULL;
9178 }
9179
9180
9181 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj;
9183 wxString *arg1 = 0 ;
9184 bool temp1 = false ;
9185 PyObject * obj0 = 0 ;
9186 char *kwnames[] = {
9187 (char *) "str", NULL
9188 };
9189
9190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9191 {
9192 arg1 = wxString_in_helper(obj0);
9193 if (arg1 == NULL) SWIG_fail;
9194 temp1 = true;
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 wxLog::RemoveTraceMask((wxString const &)*arg1);
9199
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 Py_INCREF(Py_None); resultobj = Py_None;
9204 {
9205 if (temp1)
9206 delete arg1;
9207 }
9208 return resultobj;
9209 fail:
9210 {
9211 if (temp1)
9212 delete arg1;
9213 }
9214 return NULL;
9215 }
9216
9217
9218 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9219 PyObject *resultobj;
9220 char *kwnames[] = {
9221 NULL
9222 };
9223
9224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 wxLog::ClearTraceMasks();
9228
9229 wxPyEndAllowThreads(__tstate);
9230 if (PyErr_Occurred()) SWIG_fail;
9231 }
9232 Py_INCREF(Py_None); resultobj = Py_None;
9233 return resultobj;
9234 fail:
9235 return NULL;
9236 }
9237
9238
9239 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9240 PyObject *resultobj;
9241 wxArrayString *result;
9242 char *kwnames[] = {
9243 NULL
9244 };
9245
9246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 {
9250 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9251 result = (wxArrayString *) &_result_ref;
9252 }
9253
9254 wxPyEndAllowThreads(__tstate);
9255 if (PyErr_Occurred()) SWIG_fail;
9256 }
9257 {
9258 resultobj = wxArrayString2PyList_helper(*result);
9259 }
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9267 PyObject *resultobj;
9268 wxChar *arg1 = (wxChar *) 0 ;
9269 PyObject * obj0 = 0 ;
9270 char *kwnames[] = {
9271 (char *) "ts", NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9276 if (SWIG_arg_fail(1)) SWIG_fail;
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 wxLog::SetTimestamp((wxChar const *)arg1);
9280
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 Py_INCREF(Py_None); resultobj = Py_None;
9285 return resultobj;
9286 fail:
9287 return NULL;
9288 }
9289
9290
9291 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9292 PyObject *resultobj;
9293 bool result;
9294 char *kwnames[] = {
9295 NULL
9296 };
9297
9298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 result = (bool)wxLog::GetVerbose();
9302
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 {
9307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9308 }
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj;
9317 wxTraceMask result;
9318 char *kwnames[] = {
9319 NULL
9320 };
9321
9322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9323 {
9324 PyThreadState* __tstate = wxPyBeginAllowThreads();
9325 result = (wxTraceMask)wxLog::GetTraceMask();
9326
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 {
9331 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9332 }
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9340 PyObject *resultobj;
9341 wxChar *arg1 = (wxChar *) 0 ;
9342 bool result;
9343 PyObject * obj0 = 0 ;
9344 char *kwnames[] = {
9345 (char *) "mask", NULL
9346 };
9347
9348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9350 if (SWIG_arg_fail(1)) SWIG_fail;
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9354
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 {
9359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9360 }
9361 return resultobj;
9362 fail:
9363 return NULL;
9364 }
9365
9366
9367 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9368 PyObject *resultobj;
9369 wxLogLevel result;
9370 char *kwnames[] = {
9371 NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (wxLogLevel)wxLog::GetLogLevel();
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 {
9383 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9384 }
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9392 PyObject *resultobj;
9393 wxChar *result;
9394 char *kwnames[] = {
9395 NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (wxChar *)wxLog::GetTimestamp();
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9407 return resultobj;
9408 fail:
9409 return NULL;
9410 }
9411
9412
9413 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj;
9415 wxString result;
9416 char *kwnames[] = {
9417 NULL
9418 };
9419
9420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 result = Log_TimeStamp();
9424
9425 wxPyEndAllowThreads(__tstate);
9426 if (PyErr_Occurred()) SWIG_fail;
9427 }
9428 {
9429 #if wxUSE_UNICODE
9430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9431 #else
9432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9433 #endif
9434 }
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj;
9443 wxLog *arg1 = (wxLog *) 0 ;
9444 PyObject * obj0 = 0 ;
9445 char *kwnames[] = {
9446 (char *) "self", NULL
9447 };
9448
9449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9451 if (SWIG_arg_fail(1)) SWIG_fail;
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 wxLog_Destroy(arg1);
9455
9456 wxPyEndAllowThreads(__tstate);
9457 if (PyErr_Occurred()) SWIG_fail;
9458 }
9459 Py_INCREF(Py_None); resultobj = Py_None;
9460 return resultobj;
9461 fail:
9462 return NULL;
9463 }
9464
9465
9466 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9467 PyObject *obj;
9468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9469 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9470 Py_INCREF(obj);
9471 return Py_BuildValue((char *)"");
9472 }
9473 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj;
9475 wxLogStderr *result;
9476 char *kwnames[] = {
9477 NULL
9478 };
9479
9480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9481 {
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 result = (wxLogStderr *)new wxLogStderr();
9484
9485 wxPyEndAllowThreads(__tstate);
9486 if (PyErr_Occurred()) SWIG_fail;
9487 }
9488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9489 return resultobj;
9490 fail:
9491 return NULL;
9492 }
9493
9494
9495 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9496 PyObject *obj;
9497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9498 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9499 Py_INCREF(obj);
9500 return Py_BuildValue((char *)"");
9501 }
9502 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9503 PyObject *resultobj;
9504 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9505 wxLogTextCtrl *result;
9506 PyObject * obj0 = 0 ;
9507 char *kwnames[] = {
9508 (char *) "pTextCtrl", NULL
9509 };
9510
9511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9513 if (SWIG_arg_fail(1)) SWIG_fail;
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9529 PyObject *obj;
9530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9531 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9532 Py_INCREF(obj);
9533 return Py_BuildValue((char *)"");
9534 }
9535 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj;
9537 wxLogGui *result;
9538 char *kwnames[] = {
9539 NULL
9540 };
9541
9542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 result = (wxLogGui *)new wxLogGui();
9546
9547 wxPyEndAllowThreads(__tstate);
9548 if (PyErr_Occurred()) SWIG_fail;
9549 }
9550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9558 PyObject *obj;
9559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9560 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9561 Py_INCREF(obj);
9562 return Py_BuildValue((char *)"");
9563 }
9564 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9565 PyObject *resultobj;
9566 wxFrame *arg1 = (wxFrame *) 0 ;
9567 wxString *arg2 = 0 ;
9568 bool arg3 = (bool) true ;
9569 bool arg4 = (bool) true ;
9570 wxLogWindow *result;
9571 bool temp2 = false ;
9572 PyObject * obj0 = 0 ;
9573 PyObject * obj1 = 0 ;
9574 PyObject * obj2 = 0 ;
9575 PyObject * obj3 = 0 ;
9576 char *kwnames[] = {
9577 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9578 };
9579
9580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9582 if (SWIG_arg_fail(1)) SWIG_fail;
9583 {
9584 arg2 = wxString_in_helper(obj1);
9585 if (arg2 == NULL) SWIG_fail;
9586 temp2 = true;
9587 }
9588 if (obj2) {
9589 {
9590 arg3 = (bool)(SWIG_As_bool(obj2));
9591 if (SWIG_arg_fail(3)) SWIG_fail;
9592 }
9593 }
9594 if (obj3) {
9595 {
9596 arg4 = (bool)(SWIG_As_bool(obj3));
9597 if (SWIG_arg_fail(4)) SWIG_fail;
9598 }
9599 }
9600 {
9601 PyThreadState* __tstate = wxPyBeginAllowThreads();
9602 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9603
9604 wxPyEndAllowThreads(__tstate);
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9608 {
9609 if (temp2)
9610 delete arg2;
9611 }
9612 return resultobj;
9613 fail:
9614 {
9615 if (temp2)
9616 delete arg2;
9617 }
9618 return NULL;
9619 }
9620
9621
9622 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9623 PyObject *resultobj;
9624 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9625 bool arg2 = (bool) true ;
9626 PyObject * obj0 = 0 ;
9627 PyObject * obj1 = 0 ;
9628 char *kwnames[] = {
9629 (char *) "self",(char *) "bShow", NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9634 if (SWIG_arg_fail(1)) SWIG_fail;
9635 if (obj1) {
9636 {
9637 arg2 = (bool)(SWIG_As_bool(obj1));
9638 if (SWIG_arg_fail(2)) SWIG_fail;
9639 }
9640 }
9641 {
9642 PyThreadState* __tstate = wxPyBeginAllowThreads();
9643 (arg1)->Show(arg2);
9644
9645 wxPyEndAllowThreads(__tstate);
9646 if (PyErr_Occurred()) SWIG_fail;
9647 }
9648 Py_INCREF(Py_None); resultobj = Py_None;
9649 return resultobj;
9650 fail:
9651 return NULL;
9652 }
9653
9654
9655 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9656 PyObject *resultobj;
9657 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9658 wxFrame *result;
9659 PyObject * obj0 = 0 ;
9660 char *kwnames[] = {
9661 (char *) "self", NULL
9662 };
9663
9664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9666 if (SWIG_arg_fail(1)) SWIG_fail;
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9670
9671 wxPyEndAllowThreads(__tstate);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 {
9675 resultobj = wxPyMake_wxObject(result, 0);
9676 }
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9684 PyObject *resultobj;
9685 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9686 wxLog *result;
9687 PyObject * obj0 = 0 ;
9688 char *kwnames[] = {
9689 (char *) "self", NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(1)) SWIG_fail;
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9698
9699 wxPyEndAllowThreads(__tstate);
9700 if (PyErr_Occurred()) SWIG_fail;
9701 }
9702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9703 return resultobj;
9704 fail:
9705 return NULL;
9706 }
9707
9708
9709 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9710 PyObject *resultobj;
9711 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9712 bool result;
9713 PyObject * obj0 = 0 ;
9714 char *kwnames[] = {
9715 (char *) "self", NULL
9716 };
9717
9718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(1)) SWIG_fail;
9721 {
9722 PyThreadState* __tstate = wxPyBeginAllowThreads();
9723 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9724
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 {
9729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9730 }
9731 return resultobj;
9732 fail:
9733 return NULL;
9734 }
9735
9736
9737 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj;
9739 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9740 bool arg2 ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self",(char *) "bDoPass", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 {
9751 arg2 = (bool)(SWIG_As_bool(obj1));
9752 if (SWIG_arg_fail(2)) SWIG_fail;
9753 }
9754 {
9755 PyThreadState* __tstate = wxPyBeginAllowThreads();
9756 (arg1)->PassMessages(arg2);
9757
9758 wxPyEndAllowThreads(__tstate);
9759 if (PyErr_Occurred()) SWIG_fail;
9760 }
9761 Py_INCREF(Py_None); resultobj = Py_None;
9762 return resultobj;
9763 fail:
9764 return NULL;
9765 }
9766
9767
9768 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9769 PyObject *obj;
9770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9771 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9772 Py_INCREF(obj);
9773 return Py_BuildValue((char *)"");
9774 }
9775 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9776 PyObject *resultobj;
9777 wxLog *arg1 = (wxLog *) 0 ;
9778 wxLogChain *result;
9779 PyObject * obj0 = 0 ;
9780 char *kwnames[] = {
9781 (char *) "logger", NULL
9782 };
9783
9784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9786 if (SWIG_arg_fail(1)) SWIG_fail;
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = (wxLogChain *)new wxLogChain(arg1);
9790
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9795 return resultobj;
9796 fail:
9797 return NULL;
9798 }
9799
9800
9801 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9802 PyObject *resultobj;
9803 wxLogChain *arg1 = (wxLogChain *) 0 ;
9804 wxLog *arg2 = (wxLog *) 0 ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 char *kwnames[] = {
9808 (char *) "self",(char *) "logger", NULL
9809 };
9810
9811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9813 if (SWIG_arg_fail(1)) SWIG_fail;
9814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(2)) SWIG_fail;
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 (arg1)->SetLog(arg2);
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 Py_INCREF(Py_None); resultobj = Py_None;
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9831 PyObject *resultobj;
9832 wxLogChain *arg1 = (wxLogChain *) 0 ;
9833 bool arg2 ;
9834 PyObject * obj0 = 0 ;
9835 PyObject * obj1 = 0 ;
9836 char *kwnames[] = {
9837 (char *) "self",(char *) "bDoPass", NULL
9838 };
9839
9840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9842 if (SWIG_arg_fail(1)) SWIG_fail;
9843 {
9844 arg2 = (bool)(SWIG_As_bool(obj1));
9845 if (SWIG_arg_fail(2)) SWIG_fail;
9846 }
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 (arg1)->PassMessages(arg2);
9850
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 Py_INCREF(Py_None); resultobj = Py_None;
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj;
9863 wxLogChain *arg1 = (wxLogChain *) 0 ;
9864 bool result;
9865 PyObject * obj0 = 0 ;
9866 char *kwnames[] = {
9867 (char *) "self", NULL
9868 };
9869
9870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9872 if (SWIG_arg_fail(1)) SWIG_fail;
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (bool)(arg1)->IsPassingMessages();
9876
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 {
9881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9882 }
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj;
9891 wxLogChain *arg1 = (wxLogChain *) 0 ;
9892 wxLog *result;
9893 PyObject * obj0 = 0 ;
9894 char *kwnames[] = {
9895 (char *) "self", NULL
9896 };
9897
9898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(1)) SWIG_fail;
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (wxLog *)(arg1)->GetOldLog();
9904
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9916 PyObject *obj;
9917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9918 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9919 Py_INCREF(obj);
9920 return Py_BuildValue((char *)"");
9921 }
9922 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9923 PyObject *resultobj;
9924 unsigned long result;
9925 char *kwnames[] = {
9926 NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = (unsigned long)wxSysErrorCode();
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9939 }
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj;
9948 unsigned long arg1 = (unsigned long) 0 ;
9949 wxString result;
9950 PyObject * obj0 = 0 ;
9951 char *kwnames[] = {
9952 (char *) "nErrCode", NULL
9953 };
9954
9955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9956 if (obj0) {
9957 {
9958 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9959 if (SWIG_arg_fail(1)) SWIG_fail;
9960 }
9961 }
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = wxSysErrorMsg(arg1);
9965
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 {
9970 #if wxUSE_UNICODE
9971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9972 #else
9973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9974 #endif
9975 }
9976 return resultobj;
9977 fail:
9978 return NULL;
9979 }
9980
9981
9982 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9983 PyObject *resultobj;
9984 wxString *arg1 = 0 ;
9985 bool temp1 = false ;
9986 PyObject * obj0 = 0 ;
9987 char *kwnames[] = {
9988 (char *) "msg", NULL
9989 };
9990
9991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9992 {
9993 arg1 = wxString_in_helper(obj0);
9994 if (arg1 == NULL) SWIG_fail;
9995 temp1 = true;
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 wxPyLogFatalError((wxString const &)*arg1);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 Py_INCREF(Py_None); resultobj = Py_None;
10005 {
10006 if (temp1)
10007 delete arg1;
10008 }
10009 return resultobj;
10010 fail:
10011 {
10012 if (temp1)
10013 delete arg1;
10014 }
10015 return NULL;
10016 }
10017
10018
10019 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj;
10021 wxString *arg1 = 0 ;
10022 bool temp1 = false ;
10023 PyObject * obj0 = 0 ;
10024 char *kwnames[] = {
10025 (char *) "msg", NULL
10026 };
10027
10028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10029 {
10030 arg1 = wxString_in_helper(obj0);
10031 if (arg1 == NULL) SWIG_fail;
10032 temp1 = true;
10033 }
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 wxPyLogError((wxString const &)*arg1);
10037
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 Py_INCREF(Py_None); resultobj = Py_None;
10042 {
10043 if (temp1)
10044 delete arg1;
10045 }
10046 return resultobj;
10047 fail:
10048 {
10049 if (temp1)
10050 delete arg1;
10051 }
10052 return NULL;
10053 }
10054
10055
10056 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10057 PyObject *resultobj;
10058 wxString *arg1 = 0 ;
10059 bool temp1 = false ;
10060 PyObject * obj0 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "msg", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10066 {
10067 arg1 = wxString_in_helper(obj0);
10068 if (arg1 == NULL) SWIG_fail;
10069 temp1 = true;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 wxPyLogWarning((wxString const &)*arg1);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 Py_INCREF(Py_None); resultobj = Py_None;
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp1)
10087 delete arg1;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj;
10095 wxString *arg1 = 0 ;
10096 bool temp1 = false ;
10097 PyObject * obj0 = 0 ;
10098 char *kwnames[] = {
10099 (char *) "msg", NULL
10100 };
10101
10102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10103 {
10104 arg1 = wxString_in_helper(obj0);
10105 if (arg1 == NULL) SWIG_fail;
10106 temp1 = true;
10107 }
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 wxPyLogMessage((wxString const &)*arg1);
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 Py_INCREF(Py_None); resultobj = Py_None;
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return resultobj;
10121 fail:
10122 {
10123 if (temp1)
10124 delete arg1;
10125 }
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj;
10132 wxString *arg1 = 0 ;
10133 bool temp1 = false ;
10134 PyObject * obj0 = 0 ;
10135 char *kwnames[] = {
10136 (char *) "msg", NULL
10137 };
10138
10139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10140 {
10141 arg1 = wxString_in_helper(obj0);
10142 if (arg1 == NULL) SWIG_fail;
10143 temp1 = true;
10144 }
10145 {
10146 PyThreadState* __tstate = wxPyBeginAllowThreads();
10147 wxPyLogInfo((wxString const &)*arg1);
10148
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 Py_INCREF(Py_None); resultobj = Py_None;
10153 {
10154 if (temp1)
10155 delete arg1;
10156 }
10157 return resultobj;
10158 fail:
10159 {
10160 if (temp1)
10161 delete arg1;
10162 }
10163 return NULL;
10164 }
10165
10166
10167 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10168 PyObject *resultobj;
10169 wxString *arg1 = 0 ;
10170 bool temp1 = false ;
10171 PyObject * obj0 = 0 ;
10172 char *kwnames[] = {
10173 (char *) "msg", NULL
10174 };
10175
10176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10177 {
10178 arg1 = wxString_in_helper(obj0);
10179 if (arg1 == NULL) SWIG_fail;
10180 temp1 = true;
10181 }
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 wxPyLogDebug((wxString const &)*arg1);
10185
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 Py_INCREF(Py_None); resultobj = Py_None;
10190 {
10191 if (temp1)
10192 delete arg1;
10193 }
10194 return resultobj;
10195 fail:
10196 {
10197 if (temp1)
10198 delete arg1;
10199 }
10200 return NULL;
10201 }
10202
10203
10204 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj;
10206 wxString *arg1 = 0 ;
10207 bool temp1 = false ;
10208 PyObject * obj0 = 0 ;
10209 char *kwnames[] = {
10210 (char *) "msg", NULL
10211 };
10212
10213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10214 {
10215 arg1 = wxString_in_helper(obj0);
10216 if (arg1 == NULL) SWIG_fail;
10217 temp1 = true;
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 wxPyLogVerbose((wxString const &)*arg1);
10222
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 Py_INCREF(Py_None); resultobj = Py_None;
10227 {
10228 if (temp1)
10229 delete arg1;
10230 }
10231 return resultobj;
10232 fail:
10233 {
10234 if (temp1)
10235 delete arg1;
10236 }
10237 return NULL;
10238 }
10239
10240
10241 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj;
10243 wxString *arg1 = 0 ;
10244 bool temp1 = false ;
10245 PyObject * obj0 = 0 ;
10246 char *kwnames[] = {
10247 (char *) "msg", NULL
10248 };
10249
10250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10251 {
10252 arg1 = wxString_in_helper(obj0);
10253 if (arg1 == NULL) SWIG_fail;
10254 temp1 = true;
10255 }
10256 {
10257 PyThreadState* __tstate = wxPyBeginAllowThreads();
10258 wxPyLogStatus((wxString const &)*arg1);
10259
10260 wxPyEndAllowThreads(__tstate);
10261 if (PyErr_Occurred()) SWIG_fail;
10262 }
10263 Py_INCREF(Py_None); resultobj = Py_None;
10264 {
10265 if (temp1)
10266 delete arg1;
10267 }
10268 return resultobj;
10269 fail:
10270 {
10271 if (temp1)
10272 delete arg1;
10273 }
10274 return NULL;
10275 }
10276
10277
10278 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10279 PyObject *resultobj;
10280 wxFrame *arg1 = (wxFrame *) 0 ;
10281 wxString *arg2 = 0 ;
10282 bool temp2 = false ;
10283 PyObject * obj0 = 0 ;
10284 PyObject * obj1 = 0 ;
10285 char *kwnames[] = {
10286 (char *) "pFrame",(char *) "msg", NULL
10287 };
10288
10289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10291 if (SWIG_arg_fail(1)) SWIG_fail;
10292 {
10293 arg2 = wxString_in_helper(obj1);
10294 if (arg2 == NULL) SWIG_fail;
10295 temp2 = true;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 {
10306 if (temp2)
10307 delete arg2;
10308 }
10309 return resultobj;
10310 fail:
10311 {
10312 if (temp2)
10313 delete arg2;
10314 }
10315 return NULL;
10316 }
10317
10318
10319 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10320 PyObject *resultobj;
10321 wxString *arg1 = 0 ;
10322 bool temp1 = false ;
10323 PyObject * obj0 = 0 ;
10324 char *kwnames[] = {
10325 (char *) "msg", NULL
10326 };
10327
10328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10329 {
10330 arg1 = wxString_in_helper(obj0);
10331 if (arg1 == NULL) SWIG_fail;
10332 temp1 = true;
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 wxPyLogSysError((wxString const &)*arg1);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 Py_INCREF(Py_None); resultobj = Py_None;
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return resultobj;
10347 fail:
10348 {
10349 if (temp1)
10350 delete arg1;
10351 }
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 unsigned long arg1 ;
10359 wxString *arg2 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "level",(char *) "msg", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10368 {
10369 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10370 if (SWIG_arg_fail(1)) SWIG_fail;
10371 }
10372 {
10373 arg2 = wxString_in_helper(obj1);
10374 if (arg2 == NULL) SWIG_fail;
10375 temp2 = true;
10376 }
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10380
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 Py_INCREF(Py_None); resultobj = Py_None;
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return resultobj;
10390 fail:
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return NULL;
10396 }
10397
10398
10399 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10400 PyObject *resultobj;
10401 unsigned long arg1 ;
10402 wxString *arg2 = 0 ;
10403 bool temp2 = false ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406
10407 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10408 {
10409 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10410 if (SWIG_arg_fail(1)) SWIG_fail;
10411 }
10412 {
10413 arg2 = wxString_in_helper(obj1);
10414 if (arg2 == NULL) SWIG_fail;
10415 temp2 = true;
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 wxPyLogTrace(arg1,(wxString const &)*arg2);
10420
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 Py_INCREF(Py_None); resultobj = Py_None;
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return resultobj;
10430 fail:
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10440 PyObject *resultobj;
10441 wxString *arg1 = 0 ;
10442 wxString *arg2 = 0 ;
10443 bool temp1 = false ;
10444 bool temp2 = false ;
10445 PyObject * obj0 = 0 ;
10446 PyObject * obj1 = 0 ;
10447
10448 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10449 {
10450 arg1 = wxString_in_helper(obj0);
10451 if (arg1 == NULL) SWIG_fail;
10452 temp1 = true;
10453 }
10454 {
10455 arg2 = wxString_in_helper(obj1);
10456 if (arg2 == NULL) SWIG_fail;
10457 temp2 = true;
10458 }
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10462
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 Py_INCREF(Py_None); resultobj = Py_None;
10467 {
10468 if (temp1)
10469 delete arg1;
10470 }
10471 {
10472 if (temp2)
10473 delete arg2;
10474 }
10475 return resultobj;
10476 fail:
10477 {
10478 if (temp1)
10479 delete arg1;
10480 }
10481 {
10482 if (temp2)
10483 delete arg2;
10484 }
10485 return NULL;
10486 }
10487
10488
10489 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10490 int argc;
10491 PyObject *argv[3];
10492 int ii;
10493
10494 argc = PyObject_Length(args);
10495 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10496 argv[ii] = PyTuple_GetItem(args,ii);
10497 }
10498 if (argc == 2) {
10499 int _v;
10500 {
10501 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10502 }
10503 if (_v) {
10504 {
10505 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10506 }
10507 if (_v) {
10508 return _wrap_LogTrace__SWIG_1(self,args);
10509 }
10510 }
10511 }
10512 if (argc == 2) {
10513 int _v;
10514 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10515 if (_v) {
10516 {
10517 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10518 }
10519 if (_v) {
10520 return _wrap_LogTrace__SWIG_0(self,args);
10521 }
10522 }
10523 }
10524
10525 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10526 return NULL;
10527 }
10528
10529
10530 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10531 PyObject *resultobj;
10532 wxString *arg1 = 0 ;
10533 wxString *arg2 = 0 ;
10534 bool temp1 = false ;
10535 bool temp2 = false ;
10536 PyObject * obj0 = 0 ;
10537 PyObject * obj1 = 0 ;
10538 char *kwnames[] = {
10539 (char *) "title",(char *) "text", NULL
10540 };
10541
10542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10543 {
10544 arg1 = wxString_in_helper(obj0);
10545 if (arg1 == NULL) SWIG_fail;
10546 temp1 = true;
10547 }
10548 {
10549 arg2 = wxString_in_helper(obj1);
10550 if (arg2 == NULL) SWIG_fail;
10551 temp2 = true;
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 Py_INCREF(Py_None); resultobj = Py_None;
10561 {
10562 if (temp1)
10563 delete arg1;
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return resultobj;
10570 fail:
10571 {
10572 if (temp1)
10573 delete arg1;
10574 }
10575 {
10576 if (temp2)
10577 delete arg2;
10578 }
10579 return NULL;
10580 }
10581
10582
10583 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj;
10585 wxLogNull *result;
10586 char *kwnames[] = {
10587 NULL
10588 };
10589
10590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (wxLogNull *)new wxLogNull();
10594
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10606 PyObject *resultobj;
10607 wxLogNull *arg1 = (wxLogNull *) 0 ;
10608 PyObject * obj0 = 0 ;
10609 char *kwnames[] = {
10610 (char *) "self", NULL
10611 };
10612
10613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10615 if (SWIG_arg_fail(1)) SWIG_fail;
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 delete arg1;
10619
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 Py_INCREF(Py_None); resultobj = Py_None;
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10631 PyObject *obj;
10632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10633 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10634 Py_INCREF(obj);
10635 return Py_BuildValue((char *)"");
10636 }
10637 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj;
10639 wxPyLog *result;
10640 char *kwnames[] = {
10641 NULL
10642 };
10643
10644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = (wxPyLog *)new wxPyLog();
10648
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10653 return resultobj;
10654 fail:
10655 return NULL;
10656 }
10657
10658
10659 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj;
10661 wxPyLog *arg1 = (wxPyLog *) 0 ;
10662 PyObject *arg2 = (PyObject *) 0 ;
10663 PyObject *arg3 = (PyObject *) 0 ;
10664 PyObject * obj0 = 0 ;
10665 PyObject * obj1 = 0 ;
10666 PyObject * obj2 = 0 ;
10667 char *kwnames[] = {
10668 (char *) "self",(char *) "self",(char *) "_class", NULL
10669 };
10670
10671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10673 if (SWIG_arg_fail(1)) SWIG_fail;
10674 arg2 = obj1;
10675 arg3 = obj2;
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 (arg1)->_setCallbackInfo(arg2,arg3);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 Py_INCREF(Py_None); resultobj = Py_None;
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10691 PyObject *obj;
10692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10693 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10694 Py_INCREF(obj);
10695 return Py_BuildValue((char *)"");
10696 }
10697 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj;
10699 int arg1 ;
10700 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10701 int arg3 = (int) wxKILL_NOCHILDREN ;
10702 wxKillError result;
10703 PyObject * obj0 = 0 ;
10704 PyObject * obj1 = 0 ;
10705 PyObject * obj2 = 0 ;
10706 char *kwnames[] = {
10707 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10708 };
10709
10710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10711 {
10712 arg1 = (int)(SWIG_As_int(obj0));
10713 if (SWIG_arg_fail(1)) SWIG_fail;
10714 }
10715 if (obj1) {
10716 {
10717 arg2 = (wxSignal)(SWIG_As_int(obj1));
10718 if (SWIG_arg_fail(2)) SWIG_fail;
10719 }
10720 }
10721 if (obj2) {
10722 {
10723 arg3 = (int)(SWIG_As_int(obj2));
10724 if (SWIG_arg_fail(3)) SWIG_fail;
10725 }
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 resultobj = SWIG_From_int((result));
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj;
10743 int arg1 ;
10744 bool result;
10745 PyObject * obj0 = 0 ;
10746 char *kwnames[] = {
10747 (char *) "pid", NULL
10748 };
10749
10750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10751 {
10752 arg1 = (int)(SWIG_As_int(obj0));
10753 if (SWIG_arg_fail(1)) SWIG_fail;
10754 }
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 result = (bool)wxPyProcess::Exists(arg1);
10758
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 {
10763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10764 }
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj;
10773 wxString *arg1 = 0 ;
10774 int arg2 = (int) wxEXEC_ASYNC ;
10775 wxPyProcess *result;
10776 bool temp1 = false ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char *kwnames[] = {
10780 (char *) "cmd",(char *) "flags", NULL
10781 };
10782
10783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10784 {
10785 arg1 = wxString_in_helper(obj0);
10786 if (arg1 == NULL) SWIG_fail;
10787 temp1 = true;
10788 }
10789 if (obj1) {
10790 {
10791 arg2 = (int)(SWIG_As_int(obj1));
10792 if (SWIG_arg_fail(2)) SWIG_fail;
10793 }
10794 }
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10798
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10803 {
10804 if (temp1)
10805 delete arg1;
10806 }
10807 return resultobj;
10808 fail:
10809 {
10810 if (temp1)
10811 delete arg1;
10812 }
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj;
10819 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10820 int arg2 = (int) -1 ;
10821 wxPyProcess *result;
10822 PyObject * obj0 = 0 ;
10823 PyObject * obj1 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "parent",(char *) "id", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10829 if (obj0) {
10830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10831 if (SWIG_arg_fail(1)) SWIG_fail;
10832 }
10833 if (obj1) {
10834 {
10835 arg2 = (int)(SWIG_As_int(obj1));
10836 if (SWIG_arg_fail(2)) SWIG_fail;
10837 }
10838 }
10839 {
10840 PyThreadState* __tstate = wxPyBeginAllowThreads();
10841 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10842
10843 wxPyEndAllowThreads(__tstate);
10844 if (PyErr_Occurred()) SWIG_fail;
10845 }
10846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10847 return resultobj;
10848 fail:
10849 return NULL;
10850 }
10851
10852
10853 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10854 PyObject *resultobj;
10855 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10856 PyObject *arg2 = (PyObject *) 0 ;
10857 PyObject *arg3 = (PyObject *) 0 ;
10858 PyObject * obj0 = 0 ;
10859 PyObject * obj1 = 0 ;
10860 PyObject * obj2 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "self",(char *) "self",(char *) "_class", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10867 if (SWIG_arg_fail(1)) SWIG_fail;
10868 arg2 = obj1;
10869 arg3 = obj2;
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 (arg1)->_setCallbackInfo(arg2,arg3);
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 Py_INCREF(Py_None); resultobj = Py_None;
10878 return resultobj;
10879 fail:
10880 return NULL;
10881 }
10882
10883
10884 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10885 PyObject *resultobj;
10886 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10887 int arg2 ;
10888 int arg3 ;
10889 PyObject * obj0 = 0 ;
10890 PyObject * obj1 = 0 ;
10891 PyObject * obj2 = 0 ;
10892 char *kwnames[] = {
10893 (char *) "self",(char *) "pid",(char *) "status", NULL
10894 };
10895
10896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10898 if (SWIG_arg_fail(1)) SWIG_fail;
10899 {
10900 arg2 = (int)(SWIG_As_int(obj1));
10901 if (SWIG_arg_fail(2)) SWIG_fail;
10902 }
10903 {
10904 arg3 = (int)(SWIG_As_int(obj2));
10905 if (SWIG_arg_fail(3)) SWIG_fail;
10906 }
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 (arg1)->base_OnTerminate(arg2,arg3);
10910
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 Py_INCREF(Py_None); resultobj = Py_None;
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10924 PyObject * obj0 = 0 ;
10925 char *kwnames[] = {
10926 (char *) "self", NULL
10927 };
10928
10929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10931 if (SWIG_arg_fail(1)) SWIG_fail;
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 (arg1)->Redirect();
10935
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 Py_INCREF(Py_None); resultobj = Py_None;
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10949 bool result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 result = (bool)(arg1)->IsRedirected();
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 {
10966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10967 }
10968 return resultobj;
10969 fail:
10970 return NULL;
10971 }
10972
10973
10974 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10975 PyObject *resultobj;
10976 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10977 PyObject * obj0 = 0 ;
10978 char *kwnames[] = {
10979 (char *) "self", NULL
10980 };
10981
10982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10984 if (SWIG_arg_fail(1)) SWIG_fail;
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 (arg1)->Detach();
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 Py_INCREF(Py_None); resultobj = Py_None;
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11000 PyObject *resultobj;
11001 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11002 wxInputStream *result;
11003 PyObject * obj0 = 0 ;
11004 char *kwnames[] = {
11005 (char *) "self", NULL
11006 };
11007
11008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11010 if (SWIG_arg_fail(1)) SWIG_fail;
11011 {
11012 PyThreadState* __tstate = wxPyBeginAllowThreads();
11013 result = (wxInputStream *)(arg1)->GetInputStream();
11014
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 {
11019 wxPyInputStream * _ptr = NULL;
11020
11021 if (result) {
11022 _ptr = new wxPyInputStream(result);
11023 }
11024 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11035 wxInputStream *result;
11036 PyObject * obj0 = 0 ;
11037 char *kwnames[] = {
11038 (char *) "self", NULL
11039 };
11040
11041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11043 if (SWIG_arg_fail(1)) SWIG_fail;
11044 {
11045 PyThreadState* __tstate = wxPyBeginAllowThreads();
11046 result = (wxInputStream *)(arg1)->GetErrorStream();
11047
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 {
11052 wxPyInputStream * _ptr = NULL;
11053
11054 if (result) {
11055 _ptr = new wxPyInputStream(result);
11056 }
11057 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11066 PyObject *resultobj;
11067 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11068 wxOutputStream *result;
11069 PyObject * obj0 = 0 ;
11070 char *kwnames[] = {
11071 (char *) "self", NULL
11072 };
11073
11074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11076 if (SWIG_arg_fail(1)) SWIG_fail;
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (wxOutputStream *)(arg1)->GetOutputStream();
11080
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj;
11093 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11094 PyObject * obj0 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "self", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11101 if (SWIG_arg_fail(1)) SWIG_fail;
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 (arg1)->CloseOutput();
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 Py_INCREF(Py_None); resultobj = Py_None;
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11117 PyObject *resultobj;
11118 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11119 bool result;
11120 PyObject * obj0 = 0 ;
11121 char *kwnames[] = {
11122 (char *) "self", NULL
11123 };
11124
11125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11127 if (SWIG_arg_fail(1)) SWIG_fail;
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11131
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 {
11136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11137 }
11138 return resultobj;
11139 fail:
11140 return NULL;
11141 }
11142
11143
11144 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11145 PyObject *resultobj;
11146 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11147 bool result;
11148 PyObject * obj0 = 0 ;
11149 char *kwnames[] = {
11150 (char *) "self", NULL
11151 };
11152
11153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11155 if (SWIG_arg_fail(1)) SWIG_fail;
11156 {
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 {
11164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11165 }
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11175 bool result;
11176 PyObject * obj0 = 0 ;
11177 char *kwnames[] = {
11178 (char *) "self", NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11183 if (SWIG_arg_fail(1)) SWIG_fail;
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11187
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 {
11192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11193 }
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11201 PyObject *obj;
11202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11203 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11204 Py_INCREF(obj);
11205 return Py_BuildValue((char *)"");
11206 }
11207 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 int arg1 = (int) 0 ;
11210 int arg2 = (int) 0 ;
11211 int arg3 = (int) 0 ;
11212 wxProcessEvent *result;
11213 PyObject * obj0 = 0 ;
11214 PyObject * obj1 = 0 ;
11215 PyObject * obj2 = 0 ;
11216 char *kwnames[] = {
11217 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11218 };
11219
11220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11221 if (obj0) {
11222 {
11223 arg1 = (int)(SWIG_As_int(obj0));
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 }
11226 }
11227 if (obj1) {
11228 {
11229 arg2 = (int)(SWIG_As_int(obj1));
11230 if (SWIG_arg_fail(2)) SWIG_fail;
11231 }
11232 }
11233 if (obj2) {
11234 {
11235 arg3 = (int)(SWIG_As_int(obj2));
11236 if (SWIG_arg_fail(3)) SWIG_fail;
11237 }
11238 }
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11242
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11256 int result;
11257 PyObject * obj0 = 0 ;
11258 char *kwnames[] = {
11259 (char *) "self", NULL
11260 };
11261
11262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11264 if (SWIG_arg_fail(1)) SWIG_fail;
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (int)(arg1)->GetPid();
11268
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 {
11273 resultobj = SWIG_From_int((int)(result));
11274 }
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11282 PyObject *resultobj;
11283 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11284 int result;
11285 PyObject * obj0 = 0 ;
11286 char *kwnames[] = {
11287 (char *) "self", NULL
11288 };
11289
11290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11292 if (SWIG_arg_fail(1)) SWIG_fail;
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (int)(arg1)->GetExitCode();
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = SWIG_From_int((int)(result));
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11312 int arg2 ;
11313 PyObject * obj0 = 0 ;
11314 PyObject * obj1 = 0 ;
11315 char *kwnames[] = {
11316 (char *) "self",(char *) "m_pid", NULL
11317 };
11318
11319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11321 if (SWIG_arg_fail(1)) SWIG_fail;
11322 {
11323 arg2 = (int)(SWIG_As_int(obj1));
11324 if (SWIG_arg_fail(2)) SWIG_fail;
11325 }
11326 if (arg1) (arg1)->m_pid = arg2;
11327
11328 Py_INCREF(Py_None); resultobj = Py_None;
11329 return resultobj;
11330 fail:
11331 return NULL;
11332 }
11333
11334
11335 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj;
11337 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11338 int result;
11339 PyObject * obj0 = 0 ;
11340 char *kwnames[] = {
11341 (char *) "self", NULL
11342 };
11343
11344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11346 if (SWIG_arg_fail(1)) SWIG_fail;
11347 result = (int) ((arg1)->m_pid);
11348
11349 {
11350 resultobj = SWIG_From_int((int)(result));
11351 }
11352 return resultobj;
11353 fail:
11354 return NULL;
11355 }
11356
11357
11358 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj;
11360 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11361 int arg2 ;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 char *kwnames[] = {
11365 (char *) "self",(char *) "m_exitcode", NULL
11366 };
11367
11368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11370 if (SWIG_arg_fail(1)) SWIG_fail;
11371 {
11372 arg2 = (int)(SWIG_As_int(obj1));
11373 if (SWIG_arg_fail(2)) SWIG_fail;
11374 }
11375 if (arg1) (arg1)->m_exitcode = arg2;
11376
11377 Py_INCREF(Py_None); resultobj = Py_None;
11378 return resultobj;
11379 fail:
11380 return NULL;
11381 }
11382
11383
11384 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11385 PyObject *resultobj;
11386 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11387 int result;
11388 PyObject * obj0 = 0 ;
11389 char *kwnames[] = {
11390 (char *) "self", NULL
11391 };
11392
11393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 result = (int) ((arg1)->m_exitcode);
11397
11398 {
11399 resultobj = SWIG_From_int((int)(result));
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11408 PyObject *obj;
11409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11410 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11411 Py_INCREF(obj);
11412 return Py_BuildValue((char *)"");
11413 }
11414 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj;
11416 wxString *arg1 = 0 ;
11417 int arg2 = (int) wxEXEC_ASYNC ;
11418 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11419 long result;
11420 bool temp1 = false ;
11421 PyObject * obj0 = 0 ;
11422 PyObject * obj1 = 0 ;
11423 PyObject * obj2 = 0 ;
11424 char *kwnames[] = {
11425 (char *) "command",(char *) "flags",(char *) "process", NULL
11426 };
11427
11428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11429 {
11430 arg1 = wxString_in_helper(obj0);
11431 if (arg1 == NULL) SWIG_fail;
11432 temp1 = true;
11433 }
11434 if (obj1) {
11435 {
11436 arg2 = (int)(SWIG_As_int(obj1));
11437 if (SWIG_arg_fail(2)) SWIG_fail;
11438 }
11439 }
11440 if (obj2) {
11441 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11442 if (SWIG_arg_fail(3)) SWIG_fail;
11443 }
11444 {
11445 if (!wxPyCheckForApp()) SWIG_fail;
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11448
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 {
11453 resultobj = SWIG_From_long((long)(result));
11454 }
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return resultobj;
11460 fail:
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return NULL;
11466 }
11467
11468
11469 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11470 PyObject *resultobj;
11471 long arg1 ;
11472 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11473 wxKillError *arg3 = (wxKillError *) 0 ;
11474 int arg4 = (int) wxKILL_NOCHILDREN ;
11475 int result;
11476 wxKillError temp3 ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 PyObject * obj2 = 0 ;
11480 char *kwnames[] = {
11481 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11482 };
11483
11484 {
11485 arg3 = &temp3;
11486 }
11487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11488 {
11489 arg1 = (long)(SWIG_As_long(obj0));
11490 if (SWIG_arg_fail(1)) SWIG_fail;
11491 }
11492 if (obj1) {
11493 {
11494 arg2 = (wxSignal)(SWIG_As_int(obj1));
11495 if (SWIG_arg_fail(2)) SWIG_fail;
11496 }
11497 }
11498 if (obj2) {
11499 {
11500 arg4 = (int)(SWIG_As_int(obj2));
11501 if (SWIG_arg_fail(4)) SWIG_fail;
11502 }
11503 }
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11507
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 {
11512 resultobj = SWIG_From_int((int)(result));
11513 }
11514 {
11515 PyObject* o;
11516 o = PyInt_FromLong((long) (*arg3));
11517 resultobj = t_output_helper(resultobj, o);
11518 }
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 int arg1 = (int) wxJOYSTICK1 ;
11528 wxJoystick *result;
11529 PyObject * obj0 = 0 ;
11530 char *kwnames[] = {
11531 (char *) "joystick", NULL
11532 };
11533
11534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11535 if (obj0) {
11536 {
11537 arg1 = (int)(SWIG_As_int(obj0));
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 }
11540 }
11541 {
11542 if (!wxPyCheckForApp()) SWIG_fail;
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (wxJoystick *)new wxJoystick(arg1);
11545
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11550 return resultobj;
11551 fail:
11552 return NULL;
11553 }
11554
11555
11556 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11557 PyObject *resultobj;
11558 wxJoystick *arg1 = (wxJoystick *) 0 ;
11559 PyObject * obj0 = 0 ;
11560 char *kwnames[] = {
11561 (char *) "self", NULL
11562 };
11563
11564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11566 if (SWIG_arg_fail(1)) SWIG_fail;
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 delete arg1;
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 Py_INCREF(Py_None); resultobj = Py_None;
11575 return resultobj;
11576 fail:
11577 return NULL;
11578 }
11579
11580
11581 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11582 PyObject *resultobj;
11583 wxJoystick *arg1 = (wxJoystick *) 0 ;
11584 wxPoint result;
11585 PyObject * obj0 = 0 ;
11586 char *kwnames[] = {
11587 (char *) "self", NULL
11588 };
11589
11590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11592 if (SWIG_arg_fail(1)) SWIG_fail;
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (arg1)->GetPosition();
11596
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 {
11601 wxPoint * resultptr;
11602 resultptr = new wxPoint((wxPoint &)(result));
11603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11604 }
11605 return resultobj;
11606 fail:
11607 return NULL;
11608 }
11609
11610
11611 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11612 PyObject *resultobj;
11613 wxJoystick *arg1 = (wxJoystick *) 0 ;
11614 int result;
11615 PyObject * obj0 = 0 ;
11616 char *kwnames[] = {
11617 (char *) "self", NULL
11618 };
11619
11620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11622 if (SWIG_arg_fail(1)) SWIG_fail;
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (int)(arg1)->GetZPosition();
11626
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 {
11631 resultobj = SWIG_From_int((int)(result));
11632 }
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11640 PyObject *resultobj;
11641 wxJoystick *arg1 = (wxJoystick *) 0 ;
11642 int result;
11643 PyObject * obj0 = 0 ;
11644 char *kwnames[] = {
11645 (char *) "self", NULL
11646 };
11647
11648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11650 if (SWIG_arg_fail(1)) SWIG_fail;
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (int)(arg1)->GetButtonState();
11654
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 resultobj = SWIG_From_int((int)(result));
11660 }
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj;
11669 wxJoystick *arg1 = (wxJoystick *) 0 ;
11670 int result;
11671 PyObject * obj0 = 0 ;
11672 char *kwnames[] = {
11673 (char *) "self", NULL
11674 };
11675
11676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11678 if (SWIG_arg_fail(1)) SWIG_fail;
11679 {
11680 PyThreadState* __tstate = wxPyBeginAllowThreads();
11681 result = (int)(arg1)->GetPOVPosition();
11682
11683 wxPyEndAllowThreads(__tstate);
11684 if (PyErr_Occurred()) SWIG_fail;
11685 }
11686 {
11687 resultobj = SWIG_From_int((int)(result));
11688 }
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11696 PyObject *resultobj;
11697 wxJoystick *arg1 = (wxJoystick *) 0 ;
11698 int result;
11699 PyObject * obj0 = 0 ;
11700 char *kwnames[] = {
11701 (char *) "self", NULL
11702 };
11703
11704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11706 if (SWIG_arg_fail(1)) SWIG_fail;
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (int)(arg1)->GetPOVCTSPosition();
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = SWIG_From_int((int)(result));
11716 }
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11724 PyObject *resultobj;
11725 wxJoystick *arg1 = (wxJoystick *) 0 ;
11726 int result;
11727 PyObject * obj0 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (int)(arg1)->GetRudderPosition();
11738
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 resultobj = SWIG_From_int((int)(result));
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj;
11753 wxJoystick *arg1 = (wxJoystick *) 0 ;
11754 int result;
11755 PyObject * obj0 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "self", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (int)(arg1)->GetUPosition();
11766
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = SWIG_From_int((int)(result));
11772 }
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11780 PyObject *resultobj;
11781 wxJoystick *arg1 = (wxJoystick *) 0 ;
11782 int result;
11783 PyObject * obj0 = 0 ;
11784 char *kwnames[] = {
11785 (char *) "self", NULL
11786 };
11787
11788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11790 if (SWIG_arg_fail(1)) SWIG_fail;
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (int)(arg1)->GetVPosition();
11794
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 resultobj = SWIG_From_int((int)(result));
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11808 PyObject *resultobj;
11809 wxJoystick *arg1 = (wxJoystick *) 0 ;
11810 int result;
11811 PyObject * obj0 = 0 ;
11812 char *kwnames[] = {
11813 (char *) "self", NULL
11814 };
11815
11816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11818 if (SWIG_arg_fail(1)) SWIG_fail;
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (int)(arg1)->GetMovementThreshold();
11822
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 {
11827 resultobj = SWIG_From_int((int)(result));
11828 }
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11836 PyObject *resultobj;
11837 wxJoystick *arg1 = (wxJoystick *) 0 ;
11838 int arg2 ;
11839 PyObject * obj0 = 0 ;
11840 PyObject * obj1 = 0 ;
11841 char *kwnames[] = {
11842 (char *) "self",(char *) "threshold", NULL
11843 };
11844
11845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11847 if (SWIG_arg_fail(1)) SWIG_fail;
11848 {
11849 arg2 = (int)(SWIG_As_int(obj1));
11850 if (SWIG_arg_fail(2)) SWIG_fail;
11851 }
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 (arg1)->SetMovementThreshold(arg2);
11855
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 Py_INCREF(Py_None); resultobj = Py_None;
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11867 PyObject *resultobj;
11868 wxJoystick *arg1 = (wxJoystick *) 0 ;
11869 bool result;
11870 PyObject * obj0 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (bool)(arg1)->IsOk();
11881
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj;
11896 wxJoystick *arg1 = (wxJoystick *) 0 ;
11897 int result;
11898 PyObject * obj0 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (int)(arg1)->GetNumberJoysticks();
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 resultobj = SWIG_From_int((int)(result));
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj;
11924 wxJoystick *arg1 = (wxJoystick *) 0 ;
11925 int result;
11926 PyObject * obj0 = 0 ;
11927 char *kwnames[] = {
11928 (char *) "self", NULL
11929 };
11930
11931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11933 if (SWIG_arg_fail(1)) SWIG_fail;
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (int)(arg1)->GetManufacturerId();
11937
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = SWIG_From_int((int)(result));
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj;
11952 wxJoystick *arg1 = (wxJoystick *) 0 ;
11953 int result;
11954 PyObject * obj0 = 0 ;
11955 char *kwnames[] = {
11956 (char *) "self", NULL
11957 };
11958
11959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11961 if (SWIG_arg_fail(1)) SWIG_fail;
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 result = (int)(arg1)->GetProductId();
11965
11966 wxPyEndAllowThreads(__tstate);
11967 if (PyErr_Occurred()) SWIG_fail;
11968 }
11969 {
11970 resultobj = SWIG_From_int((int)(result));
11971 }
11972 return resultobj;
11973 fail:
11974 return NULL;
11975 }
11976
11977
11978 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11979 PyObject *resultobj;
11980 wxJoystick *arg1 = (wxJoystick *) 0 ;
11981 wxString result;
11982 PyObject * obj0 = 0 ;
11983 char *kwnames[] = {
11984 (char *) "self", NULL
11985 };
11986
11987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11989 if (SWIG_arg_fail(1)) SWIG_fail;
11990 {
11991 PyThreadState* __tstate = wxPyBeginAllowThreads();
11992 result = (arg1)->GetProductName();
11993
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 {
11998 #if wxUSE_UNICODE
11999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12000 #else
12001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12002 #endif
12003 }
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj;
12012 wxJoystick *arg1 = (wxJoystick *) 0 ;
12013 int result;
12014 PyObject * obj0 = 0 ;
12015 char *kwnames[] = {
12016 (char *) "self", NULL
12017 };
12018
12019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12021 if (SWIG_arg_fail(1)) SWIG_fail;
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 result = (int)(arg1)->GetXMin();
12025
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 {
12030 resultobj = SWIG_From_int((int)(result));
12031 }
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj;
12040 wxJoystick *arg1 = (wxJoystick *) 0 ;
12041 int result;
12042 PyObject * obj0 = 0 ;
12043 char *kwnames[] = {
12044 (char *) "self", NULL
12045 };
12046
12047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12049 if (SWIG_arg_fail(1)) SWIG_fail;
12050 {
12051 PyThreadState* __tstate = wxPyBeginAllowThreads();
12052 result = (int)(arg1)->GetYMin();
12053
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 {
12058 resultobj = SWIG_From_int((int)(result));
12059 }
12060 return resultobj;
12061 fail:
12062 return NULL;
12063 }
12064
12065
12066 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12067 PyObject *resultobj;
12068 wxJoystick *arg1 = (wxJoystick *) 0 ;
12069 int result;
12070 PyObject * obj0 = 0 ;
12071 char *kwnames[] = {
12072 (char *) "self", NULL
12073 };
12074
12075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12077 if (SWIG_arg_fail(1)) SWIG_fail;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 result = (int)(arg1)->GetZMin();
12081
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 {
12086 resultobj = SWIG_From_int((int)(result));
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj;
12096 wxJoystick *arg1 = (wxJoystick *) 0 ;
12097 int result;
12098 PyObject * obj0 = 0 ;
12099 char *kwnames[] = {
12100 (char *) "self", NULL
12101 };
12102
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (int)(arg1)->GetXMax();
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 resultobj = SWIG_From_int((int)(result));
12115 }
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj;
12124 wxJoystick *arg1 = (wxJoystick *) 0 ;
12125 int result;
12126 PyObject * obj0 = 0 ;
12127 char *kwnames[] = {
12128 (char *) "self", NULL
12129 };
12130
12131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12133 if (SWIG_arg_fail(1)) SWIG_fail;
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (int)(arg1)->GetYMax();
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 resultobj = SWIG_From_int((int)(result));
12143 }
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12151 PyObject *resultobj;
12152 wxJoystick *arg1 = (wxJoystick *) 0 ;
12153 int result;
12154 PyObject * obj0 = 0 ;
12155 char *kwnames[] = {
12156 (char *) "self", NULL
12157 };
12158
12159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12161 if (SWIG_arg_fail(1)) SWIG_fail;
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (int)(arg1)->GetZMax();
12165
12166 wxPyEndAllowThreads(__tstate);
12167 if (PyErr_Occurred()) SWIG_fail;
12168 }
12169 {
12170 resultobj = SWIG_From_int((int)(result));
12171 }
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj;
12180 wxJoystick *arg1 = (wxJoystick *) 0 ;
12181 int result;
12182 PyObject * obj0 = 0 ;
12183 char *kwnames[] = {
12184 (char *) "self", NULL
12185 };
12186
12187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12189 if (SWIG_arg_fail(1)) SWIG_fail;
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = (int)(arg1)->GetNumberButtons();
12193
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 resultobj = SWIG_From_int((int)(result));
12199 }
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj;
12208 wxJoystick *arg1 = (wxJoystick *) 0 ;
12209 int result;
12210 PyObject * obj0 = 0 ;
12211 char *kwnames[] = {
12212 (char *) "self", NULL
12213 };
12214
12215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12217 if (SWIG_arg_fail(1)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (int)(arg1)->GetNumberAxes();
12221
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 {
12226 resultobj = SWIG_From_int((int)(result));
12227 }
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12235 PyObject *resultobj;
12236 wxJoystick *arg1 = (wxJoystick *) 0 ;
12237 int result;
12238 PyObject * obj0 = 0 ;
12239 char *kwnames[] = {
12240 (char *) "self", NULL
12241 };
12242
12243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12245 if (SWIG_arg_fail(1)) SWIG_fail;
12246 {
12247 PyThreadState* __tstate = wxPyBeginAllowThreads();
12248 result = (int)(arg1)->GetMaxButtons();
12249
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 {
12254 resultobj = SWIG_From_int((int)(result));
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj;
12264 wxJoystick *arg1 = (wxJoystick *) 0 ;
12265 int result;
12266 PyObject * obj0 = 0 ;
12267 char *kwnames[] = {
12268 (char *) "self", NULL
12269 };
12270
12271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12273 if (SWIG_arg_fail(1)) SWIG_fail;
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (int)(arg1)->GetMaxAxes();
12277
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 {
12282 resultobj = SWIG_From_int((int)(result));
12283 }
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj;
12292 wxJoystick *arg1 = (wxJoystick *) 0 ;
12293 int result;
12294 PyObject * obj0 = 0 ;
12295 char *kwnames[] = {
12296 (char *) "self", NULL
12297 };
12298
12299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12301 if (SWIG_arg_fail(1)) SWIG_fail;
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 result = (int)(arg1)->GetPollingMin();
12305
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = SWIG_From_int((int)(result));
12311 }
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12319 PyObject *resultobj;
12320 wxJoystick *arg1 = (wxJoystick *) 0 ;
12321 int result;
12322 PyObject * obj0 = 0 ;
12323 char *kwnames[] = {
12324 (char *) "self", NULL
12325 };
12326
12327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12329 if (SWIG_arg_fail(1)) SWIG_fail;
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = (int)(arg1)->GetPollingMax();
12333
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 {
12338 resultobj = SWIG_From_int((int)(result));
12339 }
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj;
12348 wxJoystick *arg1 = (wxJoystick *) 0 ;
12349 int result;
12350 PyObject * obj0 = 0 ;
12351 char *kwnames[] = {
12352 (char *) "self", NULL
12353 };
12354
12355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12357 if (SWIG_arg_fail(1)) SWIG_fail;
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (int)(arg1)->GetRudderMin();
12361
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 {
12366 resultobj = SWIG_From_int((int)(result));
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj;
12376 wxJoystick *arg1 = (wxJoystick *) 0 ;
12377 int result;
12378 PyObject * obj0 = 0 ;
12379 char *kwnames[] = {
12380 (char *) "self", NULL
12381 };
12382
12383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12385 if (SWIG_arg_fail(1)) SWIG_fail;
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 result = (int)(arg1)->GetRudderMax();
12389
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 resultobj = SWIG_From_int((int)(result));
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxJoystick *arg1 = (wxJoystick *) 0 ;
12405 int result;
12406 PyObject * obj0 = 0 ;
12407 char *kwnames[] = {
12408 (char *) "self", NULL
12409 };
12410
12411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12413 if (SWIG_arg_fail(1)) SWIG_fail;
12414 {
12415 PyThreadState* __tstate = wxPyBeginAllowThreads();
12416 result = (int)(arg1)->GetUMin();
12417
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 {
12422 resultobj = SWIG_From_int((int)(result));
12423 }
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj;
12432 wxJoystick *arg1 = (wxJoystick *) 0 ;
12433 int result;
12434 PyObject * obj0 = 0 ;
12435 char *kwnames[] = {
12436 (char *) "self", NULL
12437 };
12438
12439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12441 if (SWIG_arg_fail(1)) SWIG_fail;
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (int)(arg1)->GetUMax();
12445
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 {
12450 resultobj = SWIG_From_int((int)(result));
12451 }
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj;
12460 wxJoystick *arg1 = (wxJoystick *) 0 ;
12461 int result;
12462 PyObject * obj0 = 0 ;
12463 char *kwnames[] = {
12464 (char *) "self", NULL
12465 };
12466
12467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12469 if (SWIG_arg_fail(1)) SWIG_fail;
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (int)(arg1)->GetVMin();
12473
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 {
12478 resultobj = SWIG_From_int((int)(result));
12479 }
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12487 PyObject *resultobj;
12488 wxJoystick *arg1 = (wxJoystick *) 0 ;
12489 int result;
12490 PyObject * obj0 = 0 ;
12491 char *kwnames[] = {
12492 (char *) "self", NULL
12493 };
12494
12495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(1)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 result = (int)(arg1)->GetVMax();
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 {
12506 resultobj = SWIG_From_int((int)(result));
12507 }
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj;
12516 wxJoystick *arg1 = (wxJoystick *) 0 ;
12517 bool result;
12518 PyObject * obj0 = 0 ;
12519 char *kwnames[] = {
12520 (char *) "self", NULL
12521 };
12522
12523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12525 if (SWIG_arg_fail(1)) SWIG_fail;
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 result = (bool)(arg1)->HasRudder();
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 {
12534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12535 }
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12543 PyObject *resultobj;
12544 wxJoystick *arg1 = (wxJoystick *) 0 ;
12545 bool result;
12546 PyObject * obj0 = 0 ;
12547 char *kwnames[] = {
12548 (char *) "self", NULL
12549 };
12550
12551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12553 if (SWIG_arg_fail(1)) SWIG_fail;
12554 {
12555 PyThreadState* __tstate = wxPyBeginAllowThreads();
12556 result = (bool)(arg1)->HasZ();
12557
12558 wxPyEndAllowThreads(__tstate);
12559 if (PyErr_Occurred()) SWIG_fail;
12560 }
12561 {
12562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12563 }
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12571 PyObject *resultobj;
12572 wxJoystick *arg1 = (wxJoystick *) 0 ;
12573 bool result;
12574 PyObject * obj0 = 0 ;
12575 char *kwnames[] = {
12576 (char *) "self", NULL
12577 };
12578
12579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12581 if (SWIG_arg_fail(1)) SWIG_fail;
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 result = (bool)(arg1)->HasU();
12585
12586 wxPyEndAllowThreads(__tstate);
12587 if (PyErr_Occurred()) SWIG_fail;
12588 }
12589 {
12590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12591 }
12592 return resultobj;
12593 fail:
12594 return NULL;
12595 }
12596
12597
12598 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj;
12600 wxJoystick *arg1 = (wxJoystick *) 0 ;
12601 bool result;
12602 PyObject * obj0 = 0 ;
12603 char *kwnames[] = {
12604 (char *) "self", NULL
12605 };
12606
12607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12609 if (SWIG_arg_fail(1)) SWIG_fail;
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (bool)(arg1)->HasV();
12613
12614 wxPyEndAllowThreads(__tstate);
12615 if (PyErr_Occurred()) SWIG_fail;
12616 }
12617 {
12618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12619 }
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxJoystick *arg1 = (wxJoystick *) 0 ;
12629 bool result;
12630 PyObject * obj0 = 0 ;
12631 char *kwnames[] = {
12632 (char *) "self", NULL
12633 };
12634
12635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12637 if (SWIG_arg_fail(1)) SWIG_fail;
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 result = (bool)(arg1)->HasPOV();
12641
12642 wxPyEndAllowThreads(__tstate);
12643 if (PyErr_Occurred()) SWIG_fail;
12644 }
12645 {
12646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12647 }
12648 return resultobj;
12649 fail:
12650 return NULL;
12651 }
12652
12653
12654 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12655 PyObject *resultobj;
12656 wxJoystick *arg1 = (wxJoystick *) 0 ;
12657 bool result;
12658 PyObject * obj0 = 0 ;
12659 char *kwnames[] = {
12660 (char *) "self", NULL
12661 };
12662
12663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12665 if (SWIG_arg_fail(1)) SWIG_fail;
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 result = (bool)(arg1)->HasPOV4Dir();
12669
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 {
12674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12675 }
12676 return resultobj;
12677 fail:
12678 return NULL;
12679 }
12680
12681
12682 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12683 PyObject *resultobj;
12684 wxJoystick *arg1 = (wxJoystick *) 0 ;
12685 bool result;
12686 PyObject * obj0 = 0 ;
12687 char *kwnames[] = {
12688 (char *) "self", NULL
12689 };
12690
12691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12693 if (SWIG_arg_fail(1)) SWIG_fail;
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = (bool)(arg1)->HasPOVCTS();
12697
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 {
12702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12703 }
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12711 PyObject *resultobj;
12712 wxJoystick *arg1 = (wxJoystick *) 0 ;
12713 wxWindow *arg2 = (wxWindow *) 0 ;
12714 int arg3 = (int) 0 ;
12715 bool result;
12716 PyObject * obj0 = 0 ;
12717 PyObject * obj1 = 0 ;
12718 PyObject * obj2 = 0 ;
12719 char *kwnames[] = {
12720 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12721 };
12722
12723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12725 if (SWIG_arg_fail(1)) SWIG_fail;
12726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(2)) SWIG_fail;
12728 if (obj2) {
12729 {
12730 arg3 = (int)(SWIG_As_int(obj2));
12731 if (SWIG_arg_fail(3)) SWIG_fail;
12732 }
12733 }
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 result = (bool)(arg1)->SetCapture(arg2,arg3);
12737
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12743 }
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12751 PyObject *resultobj;
12752 wxJoystick *arg1 = (wxJoystick *) 0 ;
12753 bool result;
12754 PyObject * obj0 = 0 ;
12755 char *kwnames[] = {
12756 (char *) "self", NULL
12757 };
12758
12759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12761 if (SWIG_arg_fail(1)) SWIG_fail;
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 result = (bool)(arg1)->ReleaseCapture();
12765
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 {
12770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12771 }
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12779 PyObject *obj;
12780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12781 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12782 Py_INCREF(obj);
12783 return Py_BuildValue((char *)"");
12784 }
12785 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12786 PyObject *resultobj;
12787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12788 int arg2 = (int) 0 ;
12789 int arg3 = (int) wxJOYSTICK1 ;
12790 int arg4 = (int) 0 ;
12791 wxJoystickEvent *result;
12792 PyObject * obj0 = 0 ;
12793 PyObject * obj1 = 0 ;
12794 PyObject * obj2 = 0 ;
12795 PyObject * obj3 = 0 ;
12796 char *kwnames[] = {
12797 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12798 };
12799
12800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12801 if (obj0) {
12802 {
12803 arg1 = (wxEventType)(SWIG_As_int(obj0));
12804 if (SWIG_arg_fail(1)) SWIG_fail;
12805 }
12806 }
12807 if (obj1) {
12808 {
12809 arg2 = (int)(SWIG_As_int(obj1));
12810 if (SWIG_arg_fail(2)) SWIG_fail;
12811 }
12812 }
12813 if (obj2) {
12814 {
12815 arg3 = (int)(SWIG_As_int(obj2));
12816 if (SWIG_arg_fail(3)) SWIG_fail;
12817 }
12818 }
12819 if (obj3) {
12820 {
12821 arg4 = (int)(SWIG_As_int(obj3));
12822 if (SWIG_arg_fail(4)) SWIG_fail;
12823 }
12824 }
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12828
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12840 PyObject *resultobj;
12841 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12842 wxPoint result;
12843 PyObject * obj0 = 0 ;
12844 char *kwnames[] = {
12845 (char *) "self", NULL
12846 };
12847
12848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12850 if (SWIG_arg_fail(1)) SWIG_fail;
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12854
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 {
12859 wxPoint * resultptr;
12860 resultptr = new wxPoint((wxPoint &)(result));
12861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12862 }
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12870 PyObject *resultobj;
12871 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12872 int result;
12873 PyObject * obj0 = 0 ;
12874 char *kwnames[] = {
12875 (char *) "self", NULL
12876 };
12877
12878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12880 if (SWIG_arg_fail(1)) SWIG_fail;
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12884
12885 wxPyEndAllowThreads(__tstate);
12886 if (PyErr_Occurred()) SWIG_fail;
12887 }
12888 {
12889 resultobj = SWIG_From_int((int)(result));
12890 }
12891 return resultobj;
12892 fail:
12893 return NULL;
12894 }
12895
12896
12897 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12898 PyObject *resultobj;
12899 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12900 int result;
12901 PyObject * obj0 = 0 ;
12902 char *kwnames[] = {
12903 (char *) "self", NULL
12904 };
12905
12906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12908 if (SWIG_arg_fail(1)) SWIG_fail;
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 {
12917 resultobj = SWIG_From_int((int)(result));
12918 }
12919 return resultobj;
12920 fail:
12921 return NULL;
12922 }
12923
12924
12925 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12926 PyObject *resultobj;
12927 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12928 int result;
12929 PyObject * obj0 = 0 ;
12930 char *kwnames[] = {
12931 (char *) "self", NULL
12932 };
12933
12934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12936 if (SWIG_arg_fail(1)) SWIG_fail;
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12940
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 {
12945 resultobj = SWIG_From_int((int)(result));
12946 }
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12954 PyObject *resultobj;
12955 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12956 int result;
12957 PyObject * obj0 = 0 ;
12958 char *kwnames[] = {
12959 (char *) "self", NULL
12960 };
12961
12962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12964 if (SWIG_arg_fail(1)) SWIG_fail;
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12968
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 {
12973 resultobj = SWIG_From_int((int)(result));
12974 }
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12984 int arg2 ;
12985 PyObject * obj0 = 0 ;
12986 PyObject * obj1 = 0 ;
12987 char *kwnames[] = {
12988 (char *) "self",(char *) "stick", NULL
12989 };
12990
12991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12993 if (SWIG_arg_fail(1)) SWIG_fail;
12994 {
12995 arg2 = (int)(SWIG_As_int(obj1));
12996 if (SWIG_arg_fail(2)) SWIG_fail;
12997 }
12998 {
12999 PyThreadState* __tstate = wxPyBeginAllowThreads();
13000 (arg1)->SetJoystick(arg2);
13001
13002 wxPyEndAllowThreads(__tstate);
13003 if (PyErr_Occurred()) SWIG_fail;
13004 }
13005 Py_INCREF(Py_None); resultobj = Py_None;
13006 return resultobj;
13007 fail:
13008 return NULL;
13009 }
13010
13011
13012 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13013 PyObject *resultobj;
13014 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13015 int arg2 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 char *kwnames[] = {
13019 (char *) "self",(char *) "state", NULL
13020 };
13021
13022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13024 if (SWIG_arg_fail(1)) SWIG_fail;
13025 {
13026 arg2 = (int)(SWIG_As_int(obj1));
13027 if (SWIG_arg_fail(2)) SWIG_fail;
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 (arg1)->SetButtonState(arg2);
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 Py_INCREF(Py_None); resultobj = Py_None;
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj;
13045 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13046 int arg2 ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self",(char *) "change", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 arg2 = (int)(SWIG_As_int(obj1));
13058 if (SWIG_arg_fail(2)) SWIG_fail;
13059 }
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 (arg1)->SetButtonChange(arg2);
13063
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 Py_INCREF(Py_None); resultobj = Py_None;
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13077 wxPoint *arg2 = 0 ;
13078 wxPoint temp2 ;
13079 PyObject * obj0 = 0 ;
13080 PyObject * obj1 = 0 ;
13081 char *kwnames[] = {
13082 (char *) "self",(char *) "pos", NULL
13083 };
13084
13085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(1)) SWIG_fail;
13088 {
13089 arg2 = &temp2;
13090 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 (arg1)->SetPosition((wxPoint const &)*arg2);
13095
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 Py_INCREF(Py_None); resultobj = Py_None;
13100 return resultobj;
13101 fail:
13102 return NULL;
13103 }
13104
13105
13106 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13107 PyObject *resultobj;
13108 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13109 int arg2 ;
13110 PyObject * obj0 = 0 ;
13111 PyObject * obj1 = 0 ;
13112 char *kwnames[] = {
13113 (char *) "self",(char *) "zPos", NULL
13114 };
13115
13116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13118 if (SWIG_arg_fail(1)) SWIG_fail;
13119 {
13120 arg2 = (int)(SWIG_As_int(obj1));
13121 if (SWIG_arg_fail(2)) SWIG_fail;
13122 }
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 (arg1)->SetZPosition(arg2);
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 Py_INCREF(Py_None); resultobj = Py_None;
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj;
13139 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13140 bool result;
13141 PyObject * obj0 = 0 ;
13142 char *kwnames[] = {
13143 (char *) "self", NULL
13144 };
13145
13146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13148 if (SWIG_arg_fail(1)) SWIG_fail;
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 {
13157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13158 }
13159 return resultobj;
13160 fail:
13161 return NULL;
13162 }
13163
13164
13165 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13166 PyObject *resultobj;
13167 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13168 bool result;
13169 PyObject * obj0 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "self", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 {
13178 PyThreadState* __tstate = wxPyBeginAllowThreads();
13179 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13180
13181 wxPyEndAllowThreads(__tstate);
13182 if (PyErr_Occurred()) SWIG_fail;
13183 }
13184 {
13185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13186 }
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj;
13195 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13196 bool result;
13197 PyObject * obj0 = 0 ;
13198 char *kwnames[] = {
13199 (char *) "self", NULL
13200 };
13201
13202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13204 if (SWIG_arg_fail(1)) SWIG_fail;
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13208
13209 wxPyEndAllowThreads(__tstate);
13210 if (PyErr_Occurred()) SWIG_fail;
13211 }
13212 {
13213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13214 }
13215 return resultobj;
13216 fail:
13217 return NULL;
13218 }
13219
13220
13221 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13222 PyObject *resultobj;
13223 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13224 int arg2 = (int) wxJOY_BUTTON_ANY ;
13225 bool result;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 char *kwnames[] = {
13229 (char *) "self",(char *) "but", NULL
13230 };
13231
13232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13234 if (SWIG_arg_fail(1)) SWIG_fail;
13235 if (obj1) {
13236 {
13237 arg2 = (int)(SWIG_As_int(obj1));
13238 if (SWIG_arg_fail(2)) SWIG_fail;
13239 }
13240 }
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 {
13249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13250 }
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj;
13259 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13260 int arg2 = (int) wxJOY_BUTTON_ANY ;
13261 bool result;
13262 PyObject * obj0 = 0 ;
13263 PyObject * obj1 = 0 ;
13264 char *kwnames[] = {
13265 (char *) "self",(char *) "but", NULL
13266 };
13267
13268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13270 if (SWIG_arg_fail(1)) SWIG_fail;
13271 if (obj1) {
13272 {
13273 arg2 = (int)(SWIG_As_int(obj1));
13274 if (SWIG_arg_fail(2)) SWIG_fail;
13275 }
13276 }
13277 {
13278 PyThreadState* __tstate = wxPyBeginAllowThreads();
13279 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13280
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 {
13285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj;
13295 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13296 int arg2 = (int) wxJOY_BUTTON_ANY ;
13297 bool result;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 char *kwnames[] = {
13301 (char *) "self",(char *) "but", NULL
13302 };
13303
13304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13306 if (SWIG_arg_fail(1)) SWIG_fail;
13307 if (obj1) {
13308 {
13309 arg2 = (int)(SWIG_As_int(obj1));
13310 if (SWIG_arg_fail(2)) SWIG_fail;
13311 }
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13322 }
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13330 PyObject *obj;
13331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13332 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13333 Py_INCREF(obj);
13334 return Py_BuildValue((char *)"");
13335 }
13336 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13337 PyObject *resultobj;
13338 wxString const &arg1_defvalue = wxPyEmptyString ;
13339 wxString *arg1 = (wxString *) &arg1_defvalue ;
13340 wxSound *result;
13341 bool temp1 = false ;
13342 PyObject * obj0 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "fileName", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13348 if (obj0) {
13349 {
13350 arg1 = wxString_in_helper(obj0);
13351 if (arg1 == NULL) SWIG_fail;
13352 temp1 = true;
13353 }
13354 }
13355 {
13356 if (!wxPyCheckForApp()) SWIG_fail;
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13359
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13364 {
13365 if (temp1)
13366 delete arg1;
13367 }
13368 return resultobj;
13369 fail:
13370 {
13371 if (temp1)
13372 delete arg1;
13373 }
13374 return NULL;
13375 }
13376
13377
13378 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13379 PyObject *resultobj;
13380 PyObject *arg1 = (PyObject *) 0 ;
13381 wxSound *result;
13382 PyObject * obj0 = 0 ;
13383 char *kwnames[] = {
13384 (char *) "data", NULL
13385 };
13386
13387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13388 arg1 = obj0;
13389 {
13390 if (!wxPyCheckForApp()) SWIG_fail;
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (wxSound *)new_wxSound(arg1);
13393
13394 wxPyEndAllowThreads(__tstate);
13395 if (PyErr_Occurred()) SWIG_fail;
13396 }
13397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13398 return resultobj;
13399 fail:
13400 return NULL;
13401 }
13402
13403
13404 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13405 PyObject *resultobj;
13406 wxSound *arg1 = (wxSound *) 0 ;
13407 PyObject * obj0 = 0 ;
13408 char *kwnames[] = {
13409 (char *) "self", NULL
13410 };
13411
13412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13414 if (SWIG_arg_fail(1)) SWIG_fail;
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 delete arg1;
13418
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 Py_INCREF(Py_None); resultobj = Py_None;
13423 return resultobj;
13424 fail:
13425 return NULL;
13426 }
13427
13428
13429 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13430 PyObject *resultobj;
13431 wxSound *arg1 = (wxSound *) 0 ;
13432 wxString *arg2 = 0 ;
13433 bool result;
13434 bool temp2 = false ;
13435 PyObject * obj0 = 0 ;
13436 PyObject * obj1 = 0 ;
13437 char *kwnames[] = {
13438 (char *) "self",(char *) "fileName", NULL
13439 };
13440
13441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13443 if (SWIG_arg_fail(1)) SWIG_fail;
13444 {
13445 arg2 = wxString_in_helper(obj1);
13446 if (arg2 == NULL) SWIG_fail;
13447 temp2 = true;
13448 }
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 result = (bool)(arg1)->Create((wxString const &)*arg2);
13452
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 {
13457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13458 }
13459 {
13460 if (temp2)
13461 delete arg2;
13462 }
13463 return resultobj;
13464 fail:
13465 {
13466 if (temp2)
13467 delete arg2;
13468 }
13469 return NULL;
13470 }
13471
13472
13473 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13474 PyObject *resultobj;
13475 wxSound *arg1 = (wxSound *) 0 ;
13476 PyObject *arg2 = (PyObject *) 0 ;
13477 bool result;
13478 PyObject * obj0 = 0 ;
13479 PyObject * obj1 = 0 ;
13480 char *kwnames[] = {
13481 (char *) "self",(char *) "data", NULL
13482 };
13483
13484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13486 if (SWIG_arg_fail(1)) SWIG_fail;
13487 arg2 = obj1;
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 result = (bool)wxSound_CreateFromData(arg1,arg2);
13491
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 {
13496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13497 }
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj;
13506 wxSound *arg1 = (wxSound *) 0 ;
13507 bool result;
13508 PyObject * obj0 = 0 ;
13509 char *kwnames[] = {
13510 (char *) "self", NULL
13511 };
13512
13513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13515 if (SWIG_arg_fail(1)) SWIG_fail;
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (bool)(arg1)->IsOk();
13519
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 {
13524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13525 }
13526 return resultobj;
13527 fail:
13528 return NULL;
13529 }
13530
13531
13532 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13533 PyObject *resultobj;
13534 wxSound *arg1 = (wxSound *) 0 ;
13535 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13536 bool result;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 char *kwnames[] = {
13540 (char *) "self",(char *) "flags", NULL
13541 };
13542
13543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13545 if (SWIG_arg_fail(1)) SWIG_fail;
13546 if (obj1) {
13547 {
13548 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13549 if (SWIG_arg_fail(2)) SWIG_fail;
13550 }
13551 }
13552 {
13553 if (!wxPyCheckForApp()) SWIG_fail;
13554 PyThreadState* __tstate = wxPyBeginAllowThreads();
13555 result = (bool)((wxSound const *)arg1)->Play(arg2);
13556
13557 wxPyEndAllowThreads(__tstate);
13558 if (PyErr_Occurred()) SWIG_fail;
13559 }
13560 {
13561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13562 }
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj;
13571 wxString *arg1 = 0 ;
13572 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13573 bool result;
13574 bool temp1 = false ;
13575 PyObject * obj0 = 0 ;
13576 PyObject * obj1 = 0 ;
13577 char *kwnames[] = {
13578 (char *) "filename",(char *) "flags", NULL
13579 };
13580
13581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13582 {
13583 arg1 = wxString_in_helper(obj0);
13584 if (arg1 == NULL) SWIG_fail;
13585 temp1 = true;
13586 }
13587 if (obj1) {
13588 {
13589 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13590 if (SWIG_arg_fail(2)) SWIG_fail;
13591 }
13592 }
13593 {
13594 if (!wxPyCheckForApp()) SWIG_fail;
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13597
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 {
13602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13603 }
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return resultobj;
13609 fail:
13610 {
13611 if (temp1)
13612 delete arg1;
13613 }
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 char *kwnames[] = {
13621 NULL
13622 };
13623
13624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13625 {
13626 if (!wxPyCheckForApp()) SWIG_fail;
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 wxSound::Stop();
13629
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 Py_INCREF(Py_None); resultobj = Py_None;
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13641 PyObject *obj;
13642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13643 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13644 Py_INCREF(obj);
13645 return Py_BuildValue((char *)"");
13646 }
13647 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj;
13649 wxString *arg1 = 0 ;
13650 wxString *arg2 = 0 ;
13651 wxString *arg3 = 0 ;
13652 wxString *arg4 = 0 ;
13653 wxFileTypeInfo *result;
13654 bool temp1 = false ;
13655 bool temp2 = false ;
13656 bool temp3 = false ;
13657 bool temp4 = false ;
13658 PyObject * obj0 = 0 ;
13659 PyObject * obj1 = 0 ;
13660 PyObject * obj2 = 0 ;
13661 PyObject * obj3 = 0 ;
13662 char *kwnames[] = {
13663 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13664 };
13665
13666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13667 {
13668 arg1 = wxString_in_helper(obj0);
13669 if (arg1 == NULL) SWIG_fail;
13670 temp1 = true;
13671 }
13672 {
13673 arg2 = wxString_in_helper(obj1);
13674 if (arg2 == NULL) SWIG_fail;
13675 temp2 = true;
13676 }
13677 {
13678 arg3 = wxString_in_helper(obj2);
13679 if (arg3 == NULL) SWIG_fail;
13680 temp3 = true;
13681 }
13682 {
13683 arg4 = wxString_in_helper(obj3);
13684 if (arg4 == NULL) SWIG_fail;
13685 temp4 = true;
13686 }
13687 {
13688 PyThreadState* __tstate = wxPyBeginAllowThreads();
13689 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13690
13691 wxPyEndAllowThreads(__tstate);
13692 if (PyErr_Occurred()) SWIG_fail;
13693 }
13694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13695 {
13696 if (temp1)
13697 delete arg1;
13698 }
13699 {
13700 if (temp2)
13701 delete arg2;
13702 }
13703 {
13704 if (temp3)
13705 delete arg3;
13706 }
13707 {
13708 if (temp4)
13709 delete arg4;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp1)
13715 delete arg1;
13716 }
13717 {
13718 if (temp2)
13719 delete arg2;
13720 }
13721 {
13722 if (temp3)
13723 delete arg3;
13724 }
13725 {
13726 if (temp4)
13727 delete arg4;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxArrayString *arg1 = 0 ;
13736 wxFileTypeInfo *result;
13737 bool temp1 = false ;
13738 PyObject * obj0 = 0 ;
13739 char *kwnames[] = {
13740 (char *) "sArray", NULL
13741 };
13742
13743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13744 {
13745 if (! PySequence_Check(obj0)) {
13746 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13747 SWIG_fail;
13748 }
13749 arg1 = new wxArrayString;
13750 temp1 = true;
13751 int i, len=PySequence_Length(obj0);
13752 for (i=0; i<len; i++) {
13753 PyObject* item = PySequence_GetItem(obj0, i);
13754 #if wxUSE_UNICODE
13755 PyObject* str = PyObject_Unicode(item);
13756 #else
13757 PyObject* str = PyObject_Str(item);
13758 #endif
13759 if (PyErr_Occurred()) SWIG_fail;
13760 arg1->Add(Py2wxString(str));
13761 Py_DECREF(item);
13762 Py_DECREF(str);
13763 }
13764 }
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13768
13769 wxPyEndAllowThreads(__tstate);
13770 if (PyErr_Occurred()) SWIG_fail;
13771 }
13772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13773 {
13774 if (temp1) delete arg1;
13775 }
13776 return resultobj;
13777 fail:
13778 {
13779 if (temp1) delete arg1;
13780 }
13781 return NULL;
13782 }
13783
13784
13785 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj;
13787 wxFileTypeInfo *result;
13788 char *kwnames[] = {
13789 NULL
13790 };
13791
13792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13796
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13801 return resultobj;
13802 fail:
13803 return NULL;
13804 }
13805
13806
13807 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj;
13809 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13810 bool result;
13811 PyObject * obj0 = 0 ;
13812 char *kwnames[] = {
13813 (char *) "self", NULL
13814 };
13815
13816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13818 if (SWIG_arg_fail(1)) SWIG_fail;
13819 {
13820 PyThreadState* __tstate = wxPyBeginAllowThreads();
13821 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13822
13823 wxPyEndAllowThreads(__tstate);
13824 if (PyErr_Occurred()) SWIG_fail;
13825 }
13826 {
13827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13828 }
13829 return resultobj;
13830 fail:
13831 return NULL;
13832 }
13833
13834
13835 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13836 PyObject *resultobj;
13837 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13838 wxString *arg2 = 0 ;
13839 int arg3 = (int) 0 ;
13840 bool temp2 = false ;
13841 PyObject * obj0 = 0 ;
13842 PyObject * obj1 = 0 ;
13843 PyObject * obj2 = 0 ;
13844 char *kwnames[] = {
13845 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13846 };
13847
13848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13850 if (SWIG_arg_fail(1)) SWIG_fail;
13851 {
13852 arg2 = wxString_in_helper(obj1);
13853 if (arg2 == NULL) SWIG_fail;
13854 temp2 = true;
13855 }
13856 if (obj2) {
13857 {
13858 arg3 = (int)(SWIG_As_int(obj2));
13859 if (SWIG_arg_fail(3)) SWIG_fail;
13860 }
13861 }
13862 {
13863 PyThreadState* __tstate = wxPyBeginAllowThreads();
13864 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13865
13866 wxPyEndAllowThreads(__tstate);
13867 if (PyErr_Occurred()) SWIG_fail;
13868 }
13869 Py_INCREF(Py_None); resultobj = Py_None;
13870 {
13871 if (temp2)
13872 delete arg2;
13873 }
13874 return resultobj;
13875 fail:
13876 {
13877 if (temp2)
13878 delete arg2;
13879 }
13880 return NULL;
13881 }
13882
13883
13884 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj;
13886 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13887 wxString *arg2 = 0 ;
13888 bool temp2 = false ;
13889 PyObject * obj0 = 0 ;
13890 PyObject * obj1 = 0 ;
13891 char *kwnames[] = {
13892 (char *) "self",(char *) "shortDesc", NULL
13893 };
13894
13895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13897 if (SWIG_arg_fail(1)) SWIG_fail;
13898 {
13899 arg2 = wxString_in_helper(obj1);
13900 if (arg2 == NULL) SWIG_fail;
13901 temp2 = true;
13902 }
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 (arg1)->SetShortDesc((wxString const &)*arg2);
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 Py_INCREF(Py_None); resultobj = Py_None;
13911 {
13912 if (temp2)
13913 delete arg2;
13914 }
13915 return resultobj;
13916 fail:
13917 {
13918 if (temp2)
13919 delete arg2;
13920 }
13921 return NULL;
13922 }
13923
13924
13925 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13926 PyObject *resultobj;
13927 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13928 wxString *result;
13929 PyObject * obj0 = 0 ;
13930 char *kwnames[] = {
13931 (char *) "self", NULL
13932 };
13933
13934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13936 if (SWIG_arg_fail(1)) SWIG_fail;
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 {
13940 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13941 result = (wxString *) &_result_ref;
13942 }
13943
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 {
13948 #if wxUSE_UNICODE
13949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13950 #else
13951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13952 #endif
13953 }
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj;
13962 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13963 wxString *result;
13964 PyObject * obj0 = 0 ;
13965 char *kwnames[] = {
13966 (char *) "self", NULL
13967 };
13968
13969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13971 if (SWIG_arg_fail(1)) SWIG_fail;
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 {
13975 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13976 result = (wxString *) &_result_ref;
13977 }
13978
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 {
13983 #if wxUSE_UNICODE
13984 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13985 #else
13986 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13987 #endif
13988 }
13989 return resultobj;
13990 fail:
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13998 wxString *result;
13999 PyObject * obj0 = 0 ;
14000 char *kwnames[] = {
14001 (char *) "self", NULL
14002 };
14003
14004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14006 if (SWIG_arg_fail(1)) SWIG_fail;
14007 {
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 {
14010 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14011 result = (wxString *) &_result_ref;
14012 }
14013
14014 wxPyEndAllowThreads(__tstate);
14015 if (PyErr_Occurred()) SWIG_fail;
14016 }
14017 {
14018 #if wxUSE_UNICODE
14019 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14020 #else
14021 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14022 #endif
14023 }
14024 return resultobj;
14025 fail:
14026 return NULL;
14027 }
14028
14029
14030 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14031 PyObject *resultobj;
14032 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14033 wxString *result;
14034 PyObject * obj0 = 0 ;
14035 char *kwnames[] = {
14036 (char *) "self", NULL
14037 };
14038
14039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14041 if (SWIG_arg_fail(1)) SWIG_fail;
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 {
14045 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14046 result = (wxString *) &_result_ref;
14047 }
14048
14049 wxPyEndAllowThreads(__tstate);
14050 if (PyErr_Occurred()) SWIG_fail;
14051 }
14052 {
14053 #if wxUSE_UNICODE
14054 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14055 #else
14056 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14057 #endif
14058 }
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj;
14067 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14068 wxString *result;
14069 PyObject * obj0 = 0 ;
14070 char *kwnames[] = {
14071 (char *) "self", NULL
14072 };
14073
14074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14076 if (SWIG_arg_fail(1)) SWIG_fail;
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 {
14080 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14081 result = (wxString *) &_result_ref;
14082 }
14083
14084 wxPyEndAllowThreads(__tstate);
14085 if (PyErr_Occurred()) SWIG_fail;
14086 }
14087 {
14088 #if wxUSE_UNICODE
14089 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14090 #else
14091 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14092 #endif
14093 }
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14101 PyObject *resultobj;
14102 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14103 wxArrayString *result;
14104 PyObject * obj0 = 0 ;
14105 char *kwnames[] = {
14106 (char *) "self", NULL
14107 };
14108
14109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14111 if (SWIG_arg_fail(1)) SWIG_fail;
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 {
14115 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14116 result = (wxArrayString *) &_result_ref;
14117 }
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 {
14123 resultobj = wxArrayString2PyList_helper(*result);
14124 }
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj;
14133 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14134 int result;
14135 PyObject * obj0 = 0 ;
14136 char *kwnames[] = {
14137 (char *) "self", NULL
14138 };
14139
14140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14142 if (SWIG_arg_fail(1)) SWIG_fail;
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14146
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 {
14151 resultobj = SWIG_From_int((int)(result));
14152 }
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14160 PyObject *resultobj;
14161 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14162 wxString *result;
14163 PyObject * obj0 = 0 ;
14164 char *kwnames[] = {
14165 (char *) "self", NULL
14166 };
14167
14168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14170 if (SWIG_arg_fail(1)) SWIG_fail;
14171 {
14172 PyThreadState* __tstate = wxPyBeginAllowThreads();
14173 {
14174 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14175 result = (wxString *) &_result_ref;
14176 }
14177
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 {
14182 #if wxUSE_UNICODE
14183 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14184 #else
14185 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14186 #endif
14187 }
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj;
14196 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14197 int result;
14198 PyObject * obj0 = 0 ;
14199 char *kwnames[] = {
14200 (char *) "self", NULL
14201 };
14202
14203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14205 if (SWIG_arg_fail(1)) SWIG_fail;
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14209
14210 wxPyEndAllowThreads(__tstate);
14211 if (PyErr_Occurred()) SWIG_fail;
14212 }
14213 {
14214 resultobj = SWIG_From_int((int)(result));
14215 }
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14223 PyObject *obj;
14224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14225 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14226 Py_INCREF(obj);
14227 return Py_BuildValue((char *)"");
14228 }
14229 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxFileTypeInfo *arg1 = 0 ;
14232 wxFileType *result;
14233 PyObject * obj0 = 0 ;
14234 char *kwnames[] = {
14235 (char *) "ftInfo", NULL
14236 };
14237
14238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14239 {
14240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14241 if (SWIG_arg_fail(1)) SWIG_fail;
14242 if (arg1 == NULL) {
14243 SWIG_null_ref("wxFileTypeInfo");
14244 }
14245 if (SWIG_arg_fail(1)) SWIG_fail;
14246 }
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14262 PyObject *resultobj;
14263 wxFileType *arg1 = (wxFileType *) 0 ;
14264 PyObject * obj0 = 0 ;
14265 char *kwnames[] = {
14266 (char *) "self", NULL
14267 };
14268
14269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14271 if (SWIG_arg_fail(1)) SWIG_fail;
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 delete arg1;
14275
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 Py_INCREF(Py_None); resultobj = Py_None;
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj;
14288 wxFileType *arg1 = (wxFileType *) 0 ;
14289 PyObject *result;
14290 PyObject * obj0 = 0 ;
14291 char *kwnames[] = {
14292 (char *) "self", NULL
14293 };
14294
14295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14297 if (SWIG_arg_fail(1)) SWIG_fail;
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 result = (PyObject *)wxFileType_GetMimeType(arg1);
14301
14302 wxPyEndAllowThreads(__tstate);
14303 if (PyErr_Occurred()) SWIG_fail;
14304 }
14305 resultobj = result;
14306 return resultobj;
14307 fail:
14308 return NULL;
14309 }
14310
14311
14312 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14313 PyObject *resultobj;
14314 wxFileType *arg1 = (wxFileType *) 0 ;
14315 PyObject *result;
14316 PyObject * obj0 = 0 ;
14317 char *kwnames[] = {
14318 (char *) "self", NULL
14319 };
14320
14321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14323 if (SWIG_arg_fail(1)) SWIG_fail;
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = result;
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj;
14340 wxFileType *arg1 = (wxFileType *) 0 ;
14341 PyObject *result;
14342 PyObject * obj0 = 0 ;
14343 char *kwnames[] = {
14344 (char *) "self", NULL
14345 };
14346
14347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14349 if (SWIG_arg_fail(1)) SWIG_fail;
14350 {
14351 PyThreadState* __tstate = wxPyBeginAllowThreads();
14352 result = (PyObject *)wxFileType_GetExtensions(arg1);
14353
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 resultobj = result;
14358 return resultobj;
14359 fail:
14360 return NULL;
14361 }
14362
14363
14364 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14365 PyObject *resultobj;
14366 wxFileType *arg1 = (wxFileType *) 0 ;
14367 wxIcon *result;
14368 PyObject * obj0 = 0 ;
14369 char *kwnames[] = {
14370 (char *) "self", NULL
14371 };
14372
14373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14375 if (SWIG_arg_fail(1)) SWIG_fail;
14376 {
14377 PyThreadState* __tstate = wxPyBeginAllowThreads();
14378 result = (wxIcon *)wxFileType_GetIcon(arg1);
14379
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj;
14392 wxFileType *arg1 = (wxFileType *) 0 ;
14393 PyObject *result;
14394 PyObject * obj0 = 0 ;
14395 char *kwnames[] = {
14396 (char *) "self", NULL
14397 };
14398
14399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14401 if (SWIG_arg_fail(1)) SWIG_fail;
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14405
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 resultobj = result;
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxFileType *arg1 = (wxFileType *) 0 ;
14419 PyObject *result;
14420 PyObject * obj0 = 0 ;
14421 char *kwnames[] = {
14422 (char *) "self", NULL
14423 };
14424
14425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14427 if (SWIG_arg_fail(1)) SWIG_fail;
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 result = (PyObject *)wxFileType_GetDescription(arg1);
14431
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 resultobj = result;
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj;
14444 wxFileType *arg1 = (wxFileType *) 0 ;
14445 wxString *arg2 = 0 ;
14446 wxString const &arg3_defvalue = wxPyEmptyString ;
14447 wxString *arg3 = (wxString *) &arg3_defvalue ;
14448 PyObject *result;
14449 bool temp2 = false ;
14450 bool temp3 = false ;
14451 PyObject * obj0 = 0 ;
14452 PyObject * obj1 = 0 ;
14453 PyObject * obj2 = 0 ;
14454 char *kwnames[] = {
14455 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14456 };
14457
14458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14460 if (SWIG_arg_fail(1)) SWIG_fail;
14461 {
14462 arg2 = wxString_in_helper(obj1);
14463 if (arg2 == NULL) SWIG_fail;
14464 temp2 = true;
14465 }
14466 if (obj2) {
14467 {
14468 arg3 = wxString_in_helper(obj2);
14469 if (arg3 == NULL) SWIG_fail;
14470 temp3 = true;
14471 }
14472 }
14473 {
14474 PyThreadState* __tstate = wxPyBeginAllowThreads();
14475 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14476
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 resultobj = result;
14481 {
14482 if (temp2)
14483 delete arg2;
14484 }
14485 {
14486 if (temp3)
14487 delete arg3;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp2)
14493 delete arg2;
14494 }
14495 {
14496 if (temp3)
14497 delete arg3;
14498 }
14499 return NULL;
14500 }
14501
14502
14503 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj;
14505 wxFileType *arg1 = (wxFileType *) 0 ;
14506 wxString *arg2 = 0 ;
14507 wxString const &arg3_defvalue = wxPyEmptyString ;
14508 wxString *arg3 = (wxString *) &arg3_defvalue ;
14509 PyObject *result;
14510 bool temp2 = false ;
14511 bool temp3 = false ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 char *kwnames[] = {
14516 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14517 };
14518
14519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14521 if (SWIG_arg_fail(1)) SWIG_fail;
14522 {
14523 arg2 = wxString_in_helper(obj1);
14524 if (arg2 == NULL) SWIG_fail;
14525 temp2 = true;
14526 }
14527 if (obj2) {
14528 {
14529 arg3 = wxString_in_helper(obj2);
14530 if (arg3 == NULL) SWIG_fail;
14531 temp3 = true;
14532 }
14533 }
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14537
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = result;
14542 {
14543 if (temp2)
14544 delete arg2;
14545 }
14546 {
14547 if (temp3)
14548 delete arg3;
14549 }
14550 return resultobj;
14551 fail:
14552 {
14553 if (temp2)
14554 delete arg2;
14555 }
14556 {
14557 if (temp3)
14558 delete arg3;
14559 }
14560 return NULL;
14561 }
14562
14563
14564 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14565 PyObject *resultobj;
14566 wxFileType *arg1 = (wxFileType *) 0 ;
14567 wxString *arg2 = 0 ;
14568 wxString const &arg3_defvalue = wxPyEmptyString ;
14569 wxString *arg3 = (wxString *) &arg3_defvalue ;
14570 PyObject *result;
14571 bool temp2 = false ;
14572 bool temp3 = false ;
14573 PyObject * obj0 = 0 ;
14574 PyObject * obj1 = 0 ;
14575 PyObject * obj2 = 0 ;
14576 char *kwnames[] = {
14577 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14578 };
14579
14580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14582 if (SWIG_arg_fail(1)) SWIG_fail;
14583 {
14584 arg2 = wxString_in_helper(obj1);
14585 if (arg2 == NULL) SWIG_fail;
14586 temp2 = true;
14587 }
14588 if (obj2) {
14589 {
14590 arg3 = wxString_in_helper(obj2);
14591 if (arg3 == NULL) SWIG_fail;
14592 temp3 = true;
14593 }
14594 }
14595 {
14596 PyThreadState* __tstate = wxPyBeginAllowThreads();
14597 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14598
14599 wxPyEndAllowThreads(__tstate);
14600 if (PyErr_Occurred()) SWIG_fail;
14601 }
14602 resultobj = result;
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 {
14608 if (temp3)
14609 delete arg3;
14610 }
14611 return resultobj;
14612 fail:
14613 {
14614 if (temp2)
14615 delete arg2;
14616 }
14617 {
14618 if (temp3)
14619 delete arg3;
14620 }
14621 return NULL;
14622 }
14623
14624
14625 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14626 PyObject *resultobj;
14627 wxFileType *arg1 = (wxFileType *) 0 ;
14628 wxString *arg2 = 0 ;
14629 wxString *arg3 = 0 ;
14630 bool arg4 = (bool) true ;
14631 bool result;
14632 bool temp2 = false ;
14633 bool temp3 = false ;
14634 PyObject * obj0 = 0 ;
14635 PyObject * obj1 = 0 ;
14636 PyObject * obj2 = 0 ;
14637 PyObject * obj3 = 0 ;
14638 char *kwnames[] = {
14639 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14640 };
14641
14642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(1)) SWIG_fail;
14645 {
14646 arg2 = wxString_in_helper(obj1);
14647 if (arg2 == NULL) SWIG_fail;
14648 temp2 = true;
14649 }
14650 {
14651 arg3 = wxString_in_helper(obj2);
14652 if (arg3 == NULL) SWIG_fail;
14653 temp3 = true;
14654 }
14655 if (obj3) {
14656 {
14657 arg4 = (bool)(SWIG_As_bool(obj3));
14658 if (SWIG_arg_fail(4)) SWIG_fail;
14659 }
14660 }
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14664
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 {
14669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14670 }
14671 {
14672 if (temp2)
14673 delete arg2;
14674 }
14675 {
14676 if (temp3)
14677 delete arg3;
14678 }
14679 return resultobj;
14680 fail:
14681 {
14682 if (temp2)
14683 delete arg2;
14684 }
14685 {
14686 if (temp3)
14687 delete arg3;
14688 }
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxFileType *arg1 = (wxFileType *) 0 ;
14696 wxString const &arg2_defvalue = wxPyEmptyString ;
14697 wxString *arg2 = (wxString *) &arg2_defvalue ;
14698 int arg3 = (int) 0 ;
14699 bool result;
14700 bool temp2 = false ;
14701 PyObject * obj0 = 0 ;
14702 PyObject * obj1 = 0 ;
14703 PyObject * obj2 = 0 ;
14704 char *kwnames[] = {
14705 (char *) "self",(char *) "cmd",(char *) "index", NULL
14706 };
14707
14708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(1)) SWIG_fail;
14711 if (obj1) {
14712 {
14713 arg2 = wxString_in_helper(obj1);
14714 if (arg2 == NULL) SWIG_fail;
14715 temp2 = true;
14716 }
14717 }
14718 if (obj2) {
14719 {
14720 arg3 = (int)(SWIG_As_int(obj2));
14721 if (SWIG_arg_fail(3)) SWIG_fail;
14722 }
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 {
14732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14733 }
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 return resultobj;
14739 fail:
14740 {
14741 if (temp2)
14742 delete arg2;
14743 }
14744 return NULL;
14745 }
14746
14747
14748 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj;
14750 wxFileType *arg1 = (wxFileType *) 0 ;
14751 bool result;
14752 PyObject * obj0 = 0 ;
14753 char *kwnames[] = {
14754 (char *) "self", NULL
14755 };
14756
14757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14759 if (SWIG_arg_fail(1)) SWIG_fail;
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (bool)(arg1)->Unassociate();
14763
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 {
14768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14769 }
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxString *arg1 = 0 ;
14779 wxString *arg2 = 0 ;
14780 wxString const &arg3_defvalue = wxPyEmptyString ;
14781 wxString *arg3 = (wxString *) &arg3_defvalue ;
14782 wxString result;
14783 bool temp1 = false ;
14784 bool temp2 = false ;
14785 bool temp3 = false ;
14786 PyObject * obj0 = 0 ;
14787 PyObject * obj1 = 0 ;
14788 PyObject * obj2 = 0 ;
14789 char *kwnames[] = {
14790 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14791 };
14792
14793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14794 {
14795 arg1 = wxString_in_helper(obj0);
14796 if (arg1 == NULL) SWIG_fail;
14797 temp1 = true;
14798 }
14799 {
14800 arg2 = wxString_in_helper(obj1);
14801 if (arg2 == NULL) SWIG_fail;
14802 temp2 = true;
14803 }
14804 if (obj2) {
14805 {
14806 arg3 = wxString_in_helper(obj2);
14807 if (arg3 == NULL) SWIG_fail;
14808 temp3 = true;
14809 }
14810 }
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14814
14815 wxPyEndAllowThreads(__tstate);
14816 if (PyErr_Occurred()) SWIG_fail;
14817 }
14818 {
14819 #if wxUSE_UNICODE
14820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14821 #else
14822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14823 #endif
14824 }
14825 {
14826 if (temp1)
14827 delete arg1;
14828 }
14829 {
14830 if (temp2)
14831 delete arg2;
14832 }
14833 {
14834 if (temp3)
14835 delete arg3;
14836 }
14837 return resultobj;
14838 fail:
14839 {
14840 if (temp1)
14841 delete arg1;
14842 }
14843 {
14844 if (temp2)
14845 delete arg2;
14846 }
14847 {
14848 if (temp3)
14849 delete arg3;
14850 }
14851 return NULL;
14852 }
14853
14854
14855 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14856 PyObject *obj;
14857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14858 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14859 Py_INCREF(obj);
14860 return Py_BuildValue((char *)"");
14861 }
14862 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14863 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14864 return 1;
14865 }
14866
14867
14868 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14869 PyObject *pyobj;
14870
14871 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14872 return pyobj;
14873 }
14874
14875
14876 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj;
14878 wxString *arg1 = 0 ;
14879 wxString *arg2 = 0 ;
14880 bool result;
14881 bool temp1 = false ;
14882 bool temp2 = false ;
14883 PyObject * obj0 = 0 ;
14884 PyObject * obj1 = 0 ;
14885 char *kwnames[] = {
14886 (char *) "mimeType",(char *) "wildcard", NULL
14887 };
14888
14889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14890 {
14891 arg1 = wxString_in_helper(obj0);
14892 if (arg1 == NULL) SWIG_fail;
14893 temp1 = true;
14894 }
14895 {
14896 arg2 = wxString_in_helper(obj1);
14897 if (arg2 == NULL) SWIG_fail;
14898 temp2 = true;
14899 }
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14903
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 {
14908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14909 }
14910 {
14911 if (temp1)
14912 delete arg1;
14913 }
14914 {
14915 if (temp2)
14916 delete arg2;
14917 }
14918 return resultobj;
14919 fail:
14920 {
14921 if (temp1)
14922 delete arg1;
14923 }
14924 {
14925 if (temp2)
14926 delete arg2;
14927 }
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxMimeTypesManager *result;
14935 char *kwnames[] = {
14936 NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14948 return resultobj;
14949 fail:
14950 return NULL;
14951 }
14952
14953
14954 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14955 PyObject *resultobj;
14956 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14957 int arg2 = (int) wxMAILCAP_ALL ;
14958 wxString const &arg3_defvalue = wxPyEmptyString ;
14959 wxString *arg3 = (wxString *) &arg3_defvalue ;
14960 bool temp3 = false ;
14961 PyObject * obj0 = 0 ;
14962 PyObject * obj1 = 0 ;
14963 PyObject * obj2 = 0 ;
14964 char *kwnames[] = {
14965 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14966 };
14967
14968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14970 if (SWIG_arg_fail(1)) SWIG_fail;
14971 if (obj1) {
14972 {
14973 arg2 = (int)(SWIG_As_int(obj1));
14974 if (SWIG_arg_fail(2)) SWIG_fail;
14975 }
14976 }
14977 if (obj2) {
14978 {
14979 arg3 = wxString_in_helper(obj2);
14980 if (arg3 == NULL) SWIG_fail;
14981 temp3 = true;
14982 }
14983 }
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14987
14988 wxPyEndAllowThreads(__tstate);
14989 if (PyErr_Occurred()) SWIG_fail;
14990 }
14991 Py_INCREF(Py_None); resultobj = Py_None;
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return resultobj;
14997 fail:
14998 {
14999 if (temp3)
15000 delete arg3;
15001 }
15002 return NULL;
15003 }
15004
15005
15006 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15007 PyObject *resultobj;
15008 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15009 PyObject * obj0 = 0 ;
15010 char *kwnames[] = {
15011 (char *) "self", NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 (arg1)->ClearData();
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 Py_INCREF(Py_None); resultobj = Py_None;
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj;
15033 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15034 wxString *arg2 = 0 ;
15035 wxFileType *result;
15036 bool temp2 = false ;
15037 PyObject * obj0 = 0 ;
15038 PyObject * obj1 = 0 ;
15039 char *kwnames[] = {
15040 (char *) "self",(char *) "ext", NULL
15041 };
15042
15043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15045 if (SWIG_arg_fail(1)) SWIG_fail;
15046 {
15047 arg2 = wxString_in_helper(obj1);
15048 if (arg2 == NULL) SWIG_fail;
15049 temp2 = true;
15050 }
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15054
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15059 {
15060 if (temp2)
15061 delete arg2;
15062 }
15063 return resultobj;
15064 fail:
15065 {
15066 if (temp2)
15067 delete arg2;
15068 }
15069 return NULL;
15070 }
15071
15072
15073 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15074 PyObject *resultobj;
15075 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15076 wxString *arg2 = 0 ;
15077 wxFileType *result;
15078 bool temp2 = false ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 char *kwnames[] = {
15082 (char *) "self",(char *) "mimeType", NULL
15083 };
15084
15085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15087 if (SWIG_arg_fail(1)) SWIG_fail;
15088 {
15089 arg2 = wxString_in_helper(obj1);
15090 if (arg2 == NULL) SWIG_fail;
15091 temp2 = true;
15092 }
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15101 {
15102 if (temp2)
15103 delete arg2;
15104 }
15105 return resultobj;
15106 fail:
15107 {
15108 if (temp2)
15109 delete arg2;
15110 }
15111 return NULL;
15112 }
15113
15114
15115 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15116 PyObject *resultobj;
15117 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15118 wxString *arg2 = 0 ;
15119 bool arg3 = (bool) false ;
15120 bool result;
15121 bool temp2 = false ;
15122 PyObject * obj0 = 0 ;
15123 PyObject * obj1 = 0 ;
15124 PyObject * obj2 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(1)) SWIG_fail;
15132 {
15133 arg2 = wxString_in_helper(obj1);
15134 if (arg2 == NULL) SWIG_fail;
15135 temp2 = true;
15136 }
15137 if (obj2) {
15138 {
15139 arg3 = (bool)(SWIG_As_bool(obj2));
15140 if (SWIG_arg_fail(3)) SWIG_fail;
15141 }
15142 }
15143 {
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15146
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 {
15151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15152 }
15153 {
15154 if (temp2)
15155 delete arg2;
15156 }
15157 return resultobj;
15158 fail:
15159 {
15160 if (temp2)
15161 delete arg2;
15162 }
15163 return NULL;
15164 }
15165
15166
15167 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15168 PyObject *resultobj;
15169 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15170 wxString *arg2 = 0 ;
15171 bool result;
15172 bool temp2 = false ;
15173 PyObject * obj0 = 0 ;
15174 PyObject * obj1 = 0 ;
15175 char *kwnames[] = {
15176 (char *) "self",(char *) "filename", NULL
15177 };
15178
15179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15181 if (SWIG_arg_fail(1)) SWIG_fail;
15182 {
15183 arg2 = wxString_in_helper(obj1);
15184 if (arg2 == NULL) SWIG_fail;
15185 temp2 = true;
15186 }
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 {
15195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15196 }
15197 {
15198 if (temp2)
15199 delete arg2;
15200 }
15201 return resultobj;
15202 fail:
15203 {
15204 if (temp2)
15205 delete arg2;
15206 }
15207 return NULL;
15208 }
15209
15210
15211 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15212 PyObject *resultobj;
15213 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15214 PyObject *result;
15215 PyObject * obj0 = 0 ;
15216 char *kwnames[] = {
15217 (char *) "self", NULL
15218 };
15219
15220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15222 if (SWIG_arg_fail(1)) SWIG_fail;
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15226
15227 wxPyEndAllowThreads(__tstate);
15228 if (PyErr_Occurred()) SWIG_fail;
15229 }
15230 resultobj = result;
15231 return resultobj;
15232 fail:
15233 return NULL;
15234 }
15235
15236
15237 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15238 PyObject *resultobj;
15239 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15240 wxFileTypeInfo *arg2 = 0 ;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "self",(char *) "ft", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15249 if (SWIG_arg_fail(1)) SWIG_fail;
15250 {
15251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(2)) SWIG_fail;
15253 if (arg2 == NULL) {
15254 SWIG_null_ref("wxFileTypeInfo");
15255 }
15256 if (SWIG_arg_fail(2)) SWIG_fail;
15257 }
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15261
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 Py_INCREF(Py_None); resultobj = Py_None;
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15273 PyObject *resultobj;
15274 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15275 wxFileTypeInfo *arg2 = 0 ;
15276 wxFileType *result;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self",(char *) "ftInfo", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15285 if (SWIG_arg_fail(1)) SWIG_fail;
15286 {
15287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(2)) SWIG_fail;
15289 if (arg2 == NULL) {
15290 SWIG_null_ref("wxFileTypeInfo");
15291 }
15292 if (SWIG_arg_fail(2)) SWIG_fail;
15293 }
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15297
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15309 PyObject *resultobj;
15310 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15311 wxFileType *arg2 = (wxFileType *) 0 ;
15312 bool result;
15313 PyObject * obj0 = 0 ;
15314 PyObject * obj1 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self",(char *) "ft", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(2)) SWIG_fail;
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 result = (bool)(arg1)->Unassociate(arg2);
15327
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 {
15332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15333 }
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj;
15342 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15343 PyObject * obj0 = 0 ;
15344 char *kwnames[] = {
15345 (char *) "self", NULL
15346 };
15347
15348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15350 if (SWIG_arg_fail(1)) SWIG_fail;
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 delete arg1;
15354
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 Py_INCREF(Py_None); resultobj = Py_None;
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15366 PyObject *obj;
15367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15368 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15369 Py_INCREF(obj);
15370 return Py_BuildValue((char *)"");
15371 }
15372 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15373 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15374 return 1;
15375 }
15376
15377
15378 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15379 PyObject *pyobj;
15380
15381 {
15382 #if wxUSE_UNICODE
15383 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15384 #else
15385 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15386 #endif
15387 }
15388 return pyobj;
15389 }
15390
15391
15392 static int _wrap_ART_MENU_set(PyObject *) {
15393 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15394 return 1;
15395 }
15396
15397
15398 static PyObject *_wrap_ART_MENU_get(void) {
15399 PyObject *pyobj;
15400
15401 {
15402 #if wxUSE_UNICODE
15403 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15404 #else
15405 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15406 #endif
15407 }
15408 return pyobj;
15409 }
15410
15411
15412 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15413 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15414 return 1;
15415 }
15416
15417
15418 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15419 PyObject *pyobj;
15420
15421 {
15422 #if wxUSE_UNICODE
15423 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15424 #else
15425 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15426 #endif
15427 }
15428 return pyobj;
15429 }
15430
15431
15432 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15433 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15434 return 1;
15435 }
15436
15437
15438 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15439 PyObject *pyobj;
15440
15441 {
15442 #if wxUSE_UNICODE
15443 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15444 #else
15445 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15446 #endif
15447 }
15448 return pyobj;
15449 }
15450
15451
15452 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15453 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15454 return 1;
15455 }
15456
15457
15458 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15459 PyObject *pyobj;
15460
15461 {
15462 #if wxUSE_UNICODE
15463 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15464 #else
15465 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15466 #endif
15467 }
15468 return pyobj;
15469 }
15470
15471
15472 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15473 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15474 return 1;
15475 }
15476
15477
15478 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15479 PyObject *pyobj;
15480
15481 {
15482 #if wxUSE_UNICODE
15483 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15484 #else
15485 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15486 #endif
15487 }
15488 return pyobj;
15489 }
15490
15491
15492 static int _wrap_ART_BUTTON_set(PyObject *) {
15493 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15494 return 1;
15495 }
15496
15497
15498 static PyObject *_wrap_ART_BUTTON_get(void) {
15499 PyObject *pyobj;
15500
15501 {
15502 #if wxUSE_UNICODE
15503 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15504 #else
15505 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15506 #endif
15507 }
15508 return pyobj;
15509 }
15510
15511
15512 static int _wrap_ART_OTHER_set(PyObject *) {
15513 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15514 return 1;
15515 }
15516
15517
15518 static PyObject *_wrap_ART_OTHER_get(void) {
15519 PyObject *pyobj;
15520
15521 {
15522 #if wxUSE_UNICODE
15523 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15524 #else
15525 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15526 #endif
15527 }
15528 return pyobj;
15529 }
15530
15531
15532 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15533 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15534 return 1;
15535 }
15536
15537
15538 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15539 PyObject *pyobj;
15540
15541 {
15542 #if wxUSE_UNICODE
15543 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15544 #else
15545 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15546 #endif
15547 }
15548 return pyobj;
15549 }
15550
15551
15552 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15553 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15554 return 1;
15555 }
15556
15557
15558 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15559 PyObject *pyobj;
15560
15561 {
15562 #if wxUSE_UNICODE
15563 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15564 #else
15565 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15566 #endif
15567 }
15568 return pyobj;
15569 }
15570
15571
15572 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15573 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15574 return 1;
15575 }
15576
15577
15578 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15579 PyObject *pyobj;
15580
15581 {
15582 #if wxUSE_UNICODE
15583 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15584 #else
15585 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15586 #endif
15587 }
15588 return pyobj;
15589 }
15590
15591
15592 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15593 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15594 return 1;
15595 }
15596
15597
15598 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15599 PyObject *pyobj;
15600
15601 {
15602 #if wxUSE_UNICODE
15603 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15604 #else
15605 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15606 #endif
15607 }
15608 return pyobj;
15609 }
15610
15611
15612 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15613 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15614 return 1;
15615 }
15616
15617
15618 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15619 PyObject *pyobj;
15620
15621 {
15622 #if wxUSE_UNICODE
15623 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15624 #else
15625 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15626 #endif
15627 }
15628 return pyobj;
15629 }
15630
15631
15632 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15633 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15634 return 1;
15635 }
15636
15637
15638 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15639 PyObject *pyobj;
15640
15641 {
15642 #if wxUSE_UNICODE
15643 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15644 #else
15645 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15646 #endif
15647 }
15648 return pyobj;
15649 }
15650
15651
15652 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15653 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15654 return 1;
15655 }
15656
15657
15658 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15659 PyObject *pyobj;
15660
15661 {
15662 #if wxUSE_UNICODE
15663 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15664 #else
15665 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15666 #endif
15667 }
15668 return pyobj;
15669 }
15670
15671
15672 static int _wrap_ART_GO_BACK_set(PyObject *) {
15673 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15674 return 1;
15675 }
15676
15677
15678 static PyObject *_wrap_ART_GO_BACK_get(void) {
15679 PyObject *pyobj;
15680
15681 {
15682 #if wxUSE_UNICODE
15683 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15684 #else
15685 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15686 #endif
15687 }
15688 return pyobj;
15689 }
15690
15691
15692 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15693 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15694 return 1;
15695 }
15696
15697
15698 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15699 PyObject *pyobj;
15700
15701 {
15702 #if wxUSE_UNICODE
15703 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15704 #else
15705 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15706 #endif
15707 }
15708 return pyobj;
15709 }
15710
15711
15712 static int _wrap_ART_GO_UP_set(PyObject *) {
15713 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15714 return 1;
15715 }
15716
15717
15718 static PyObject *_wrap_ART_GO_UP_get(void) {
15719 PyObject *pyobj;
15720
15721 {
15722 #if wxUSE_UNICODE
15723 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15724 #else
15725 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15726 #endif
15727 }
15728 return pyobj;
15729 }
15730
15731
15732 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15733 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15734 return 1;
15735 }
15736
15737
15738 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15739 PyObject *pyobj;
15740
15741 {
15742 #if wxUSE_UNICODE
15743 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15744 #else
15745 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15746 #endif
15747 }
15748 return pyobj;
15749 }
15750
15751
15752 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15753 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15754 return 1;
15755 }
15756
15757
15758 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15759 PyObject *pyobj;
15760
15761 {
15762 #if wxUSE_UNICODE
15763 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15764 #else
15765 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15766 #endif
15767 }
15768 return pyobj;
15769 }
15770
15771
15772 static int _wrap_ART_GO_HOME_set(PyObject *) {
15773 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15774 return 1;
15775 }
15776
15777
15778 static PyObject *_wrap_ART_GO_HOME_get(void) {
15779 PyObject *pyobj;
15780
15781 {
15782 #if wxUSE_UNICODE
15783 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15784 #else
15785 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15786 #endif
15787 }
15788 return pyobj;
15789 }
15790
15791
15792 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15793 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15794 return 1;
15795 }
15796
15797
15798 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15799 PyObject *pyobj;
15800
15801 {
15802 #if wxUSE_UNICODE
15803 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15804 #else
15805 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15806 #endif
15807 }
15808 return pyobj;
15809 }
15810
15811
15812 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15813 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15814 return 1;
15815 }
15816
15817
15818 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15819 PyObject *pyobj;
15820
15821 {
15822 #if wxUSE_UNICODE
15823 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15824 #else
15825 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15826 #endif
15827 }
15828 return pyobj;
15829 }
15830
15831
15832 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15833 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15834 return 1;
15835 }
15836
15837
15838 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15839 PyObject *pyobj;
15840
15841 {
15842 #if wxUSE_UNICODE
15843 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15844 #else
15845 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15846 #endif
15847 }
15848 return pyobj;
15849 }
15850
15851
15852 static int _wrap_ART_PRINT_set(PyObject *) {
15853 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15854 return 1;
15855 }
15856
15857
15858 static PyObject *_wrap_ART_PRINT_get(void) {
15859 PyObject *pyobj;
15860
15861 {
15862 #if wxUSE_UNICODE
15863 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15864 #else
15865 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15866 #endif
15867 }
15868 return pyobj;
15869 }
15870
15871
15872 static int _wrap_ART_HELP_set(PyObject *) {
15873 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15874 return 1;
15875 }
15876
15877
15878 static PyObject *_wrap_ART_HELP_get(void) {
15879 PyObject *pyobj;
15880
15881 {
15882 #if wxUSE_UNICODE
15883 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15884 #else
15885 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15886 #endif
15887 }
15888 return pyobj;
15889 }
15890
15891
15892 static int _wrap_ART_TIP_set(PyObject *) {
15893 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15894 return 1;
15895 }
15896
15897
15898 static PyObject *_wrap_ART_TIP_get(void) {
15899 PyObject *pyobj;
15900
15901 {
15902 #if wxUSE_UNICODE
15903 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15904 #else
15905 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15906 #endif
15907 }
15908 return pyobj;
15909 }
15910
15911
15912 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15913 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15914 return 1;
15915 }
15916
15917
15918 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15919 PyObject *pyobj;
15920
15921 {
15922 #if wxUSE_UNICODE
15923 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15924 #else
15925 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15926 #endif
15927 }
15928 return pyobj;
15929 }
15930
15931
15932 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15933 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15934 return 1;
15935 }
15936
15937
15938 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15939 PyObject *pyobj;
15940
15941 {
15942 #if wxUSE_UNICODE
15943 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15944 #else
15945 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15946 #endif
15947 }
15948 return pyobj;
15949 }
15950
15951
15952 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15953 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15954 return 1;
15955 }
15956
15957
15958 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15959 PyObject *pyobj;
15960
15961 {
15962 #if wxUSE_UNICODE
15963 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15964 #else
15965 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15966 #endif
15967 }
15968 return pyobj;
15969 }
15970
15971
15972 static int _wrap_ART_HARDDISK_set(PyObject *) {
15973 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15974 return 1;
15975 }
15976
15977
15978 static PyObject *_wrap_ART_HARDDISK_get(void) {
15979 PyObject *pyobj;
15980
15981 {
15982 #if wxUSE_UNICODE
15983 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15984 #else
15985 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15986 #endif
15987 }
15988 return pyobj;
15989 }
15990
15991
15992 static int _wrap_ART_FLOPPY_set(PyObject *) {
15993 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15994 return 1;
15995 }
15996
15997
15998 static PyObject *_wrap_ART_FLOPPY_get(void) {
15999 PyObject *pyobj;
16000
16001 {
16002 #if wxUSE_UNICODE
16003 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16004 #else
16005 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16006 #endif
16007 }
16008 return pyobj;
16009 }
16010
16011
16012 static int _wrap_ART_CDROM_set(PyObject *) {
16013 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16014 return 1;
16015 }
16016
16017
16018 static PyObject *_wrap_ART_CDROM_get(void) {
16019 PyObject *pyobj;
16020
16021 {
16022 #if wxUSE_UNICODE
16023 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16024 #else
16025 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16026 #endif
16027 }
16028 return pyobj;
16029 }
16030
16031
16032 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16033 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16034 return 1;
16035 }
16036
16037
16038 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16039 PyObject *pyobj;
16040
16041 {
16042 #if wxUSE_UNICODE
16043 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16044 #else
16045 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16046 #endif
16047 }
16048 return pyobj;
16049 }
16050
16051
16052 static int _wrap_ART_FOLDER_set(PyObject *) {
16053 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16054 return 1;
16055 }
16056
16057
16058 static PyObject *_wrap_ART_FOLDER_get(void) {
16059 PyObject *pyobj;
16060
16061 {
16062 #if wxUSE_UNICODE
16063 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16064 #else
16065 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16066 #endif
16067 }
16068 return pyobj;
16069 }
16070
16071
16072 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16073 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16074 return 1;
16075 }
16076
16077
16078 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16079 PyObject *pyobj;
16080
16081 {
16082 #if wxUSE_UNICODE
16083 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16084 #else
16085 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16086 #endif
16087 }
16088 return pyobj;
16089 }
16090
16091
16092 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16093 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16094 return 1;
16095 }
16096
16097
16098 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16099 PyObject *pyobj;
16100
16101 {
16102 #if wxUSE_UNICODE
16103 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16104 #else
16105 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16106 #endif
16107 }
16108 return pyobj;
16109 }
16110
16111
16112 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16113 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16114 return 1;
16115 }
16116
16117
16118 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16119 PyObject *pyobj;
16120
16121 {
16122 #if wxUSE_UNICODE
16123 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16124 #else
16125 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16126 #endif
16127 }
16128 return pyobj;
16129 }
16130
16131
16132 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16133 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16134 return 1;
16135 }
16136
16137
16138 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16139 PyObject *pyobj;
16140
16141 {
16142 #if wxUSE_UNICODE
16143 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16144 #else
16145 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16146 #endif
16147 }
16148 return pyobj;
16149 }
16150
16151
16152 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16153 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16154 return 1;
16155 }
16156
16157
16158 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16159 PyObject *pyobj;
16160
16161 {
16162 #if wxUSE_UNICODE
16163 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16164 #else
16165 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16166 #endif
16167 }
16168 return pyobj;
16169 }
16170
16171
16172 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16173 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16174 return 1;
16175 }
16176
16177
16178 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16179 PyObject *pyobj;
16180
16181 {
16182 #if wxUSE_UNICODE
16183 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16184 #else
16185 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16186 #endif
16187 }
16188 return pyobj;
16189 }
16190
16191
16192 static int _wrap_ART_ERROR_set(PyObject *) {
16193 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16194 return 1;
16195 }
16196
16197
16198 static PyObject *_wrap_ART_ERROR_get(void) {
16199 PyObject *pyobj;
16200
16201 {
16202 #if wxUSE_UNICODE
16203 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16204 #else
16205 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16206 #endif
16207 }
16208 return pyobj;
16209 }
16210
16211
16212 static int _wrap_ART_QUESTION_set(PyObject *) {
16213 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16214 return 1;
16215 }
16216
16217
16218 static PyObject *_wrap_ART_QUESTION_get(void) {
16219 PyObject *pyobj;
16220
16221 {
16222 #if wxUSE_UNICODE
16223 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16224 #else
16225 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16226 #endif
16227 }
16228 return pyobj;
16229 }
16230
16231
16232 static int _wrap_ART_WARNING_set(PyObject *) {
16233 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16234 return 1;
16235 }
16236
16237
16238 static PyObject *_wrap_ART_WARNING_get(void) {
16239 PyObject *pyobj;
16240
16241 {
16242 #if wxUSE_UNICODE
16243 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16244 #else
16245 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16246 #endif
16247 }
16248 return pyobj;
16249 }
16250
16251
16252 static int _wrap_ART_INFORMATION_set(PyObject *) {
16253 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16254 return 1;
16255 }
16256
16257
16258 static PyObject *_wrap_ART_INFORMATION_get(void) {
16259 PyObject *pyobj;
16260
16261 {
16262 #if wxUSE_UNICODE
16263 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16264 #else
16265 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16266 #endif
16267 }
16268 return pyobj;
16269 }
16270
16271
16272 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16273 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16274 return 1;
16275 }
16276
16277
16278 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16279 PyObject *pyobj;
16280
16281 {
16282 #if wxUSE_UNICODE
16283 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16284 #else
16285 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16286 #endif
16287 }
16288 return pyobj;
16289 }
16290
16291
16292 static int _wrap_ART_COPY_set(PyObject *) {
16293 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16294 return 1;
16295 }
16296
16297
16298 static PyObject *_wrap_ART_COPY_get(void) {
16299 PyObject *pyobj;
16300
16301 {
16302 #if wxUSE_UNICODE
16303 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16304 #else
16305 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16306 #endif
16307 }
16308 return pyobj;
16309 }
16310
16311
16312 static int _wrap_ART_CUT_set(PyObject *) {
16313 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16314 return 1;
16315 }
16316
16317
16318 static PyObject *_wrap_ART_CUT_get(void) {
16319 PyObject *pyobj;
16320
16321 {
16322 #if wxUSE_UNICODE
16323 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16324 #else
16325 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16326 #endif
16327 }
16328 return pyobj;
16329 }
16330
16331
16332 static int _wrap_ART_PASTE_set(PyObject *) {
16333 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16334 return 1;
16335 }
16336
16337
16338 static PyObject *_wrap_ART_PASTE_get(void) {
16339 PyObject *pyobj;
16340
16341 {
16342 #if wxUSE_UNICODE
16343 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16344 #else
16345 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16346 #endif
16347 }
16348 return pyobj;
16349 }
16350
16351
16352 static int _wrap_ART_DELETE_set(PyObject *) {
16353 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16354 return 1;
16355 }
16356
16357
16358 static PyObject *_wrap_ART_DELETE_get(void) {
16359 PyObject *pyobj;
16360
16361 {
16362 #if wxUSE_UNICODE
16363 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16364 #else
16365 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16366 #endif
16367 }
16368 return pyobj;
16369 }
16370
16371
16372 static int _wrap_ART_UNDO_set(PyObject *) {
16373 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16374 return 1;
16375 }
16376
16377
16378 static PyObject *_wrap_ART_UNDO_get(void) {
16379 PyObject *pyobj;
16380
16381 {
16382 #if wxUSE_UNICODE
16383 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16384 #else
16385 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16386 #endif
16387 }
16388 return pyobj;
16389 }
16390
16391
16392 static int _wrap_ART_REDO_set(PyObject *) {
16393 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16394 return 1;
16395 }
16396
16397
16398 static PyObject *_wrap_ART_REDO_get(void) {
16399 PyObject *pyobj;
16400
16401 {
16402 #if wxUSE_UNICODE
16403 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16404 #else
16405 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16406 #endif
16407 }
16408 return pyobj;
16409 }
16410
16411
16412 static int _wrap_ART_QUIT_set(PyObject *) {
16413 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16414 return 1;
16415 }
16416
16417
16418 static PyObject *_wrap_ART_QUIT_get(void) {
16419 PyObject *pyobj;
16420
16421 {
16422 #if wxUSE_UNICODE
16423 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16424 #else
16425 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16426 #endif
16427 }
16428 return pyobj;
16429 }
16430
16431
16432 static int _wrap_ART_FIND_set(PyObject *) {
16433 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16434 return 1;
16435 }
16436
16437
16438 static PyObject *_wrap_ART_FIND_get(void) {
16439 PyObject *pyobj;
16440
16441 {
16442 #if wxUSE_UNICODE
16443 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16444 #else
16445 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16446 #endif
16447 }
16448 return pyobj;
16449 }
16450
16451
16452 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16453 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16454 return 1;
16455 }
16456
16457
16458 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16459 PyObject *pyobj;
16460
16461 {
16462 #if wxUSE_UNICODE
16463 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16464 #else
16465 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16466 #endif
16467 }
16468 return pyobj;
16469 }
16470
16471
16472 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj;
16474 wxPyArtProvider *result;
16475 char *kwnames[] = {
16476 NULL
16477 };
16478
16479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16480 {
16481 if (!wxPyCheckForApp()) SWIG_fail;
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (wxPyArtProvider *)new wxPyArtProvider();
16484
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj;
16497 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16498 PyObject *arg2 = (PyObject *) 0 ;
16499 PyObject *arg3 = (PyObject *) 0 ;
16500 PyObject * obj0 = 0 ;
16501 PyObject * obj1 = 0 ;
16502 PyObject * obj2 = 0 ;
16503 char *kwnames[] = {
16504 (char *) "self",(char *) "self",(char *) "_class", NULL
16505 };
16506
16507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16509 if (SWIG_arg_fail(1)) SWIG_fail;
16510 arg2 = obj1;
16511 arg3 = obj2;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 (arg1)->_setCallbackInfo(arg2,arg3);
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 Py_INCREF(Py_None); resultobj = Py_None;
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj;
16528 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16529 PyObject * obj0 = 0 ;
16530 char *kwnames[] = {
16531 (char *) "provider", NULL
16532 };
16533
16534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16536 if (SWIG_arg_fail(1)) SWIG_fail;
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 wxPyArtProvider::PushProvider(arg1);
16540
16541 wxPyEndAllowThreads(__tstate);
16542 if (PyErr_Occurred()) SWIG_fail;
16543 }
16544 Py_INCREF(Py_None); resultobj = Py_None;
16545 return resultobj;
16546 fail:
16547 return NULL;
16548 }
16549
16550
16551 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16552 PyObject *resultobj;
16553 bool result;
16554 char *kwnames[] = {
16555 NULL
16556 };
16557
16558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)wxPyArtProvider::PopProvider();
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj;
16577 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16578 bool result;
16579 PyObject * obj0 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "provider", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxString *arg1 = 0 ;
16606 wxString const &arg2_defvalue = wxPyART_OTHER ;
16607 wxString *arg2 = (wxString *) &arg2_defvalue ;
16608 wxSize const &arg3_defvalue = wxDefaultSize ;
16609 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16610 wxBitmap result;
16611 bool temp1 = false ;
16612 bool temp2 = false ;
16613 wxSize temp3 ;
16614 PyObject * obj0 = 0 ;
16615 PyObject * obj1 = 0 ;
16616 PyObject * obj2 = 0 ;
16617 char *kwnames[] = {
16618 (char *) "id",(char *) "client",(char *) "size", NULL
16619 };
16620
16621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16622 {
16623 arg1 = wxString_in_helper(obj0);
16624 if (arg1 == NULL) SWIG_fail;
16625 temp1 = true;
16626 }
16627 if (obj1) {
16628 {
16629 arg2 = wxString_in_helper(obj1);
16630 if (arg2 == NULL) SWIG_fail;
16631 temp2 = true;
16632 }
16633 }
16634 if (obj2) {
16635 {
16636 arg3 = &temp3;
16637 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16638 }
16639 }
16640 {
16641 if (!wxPyCheckForApp()) SWIG_fail;
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16644
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 {
16649 wxBitmap * resultptr;
16650 resultptr = new wxBitmap((wxBitmap &)(result));
16651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16652 }
16653 {
16654 if (temp1)
16655 delete arg1;
16656 }
16657 {
16658 if (temp2)
16659 delete arg2;
16660 }
16661 return resultobj;
16662 fail:
16663 {
16664 if (temp1)
16665 delete arg1;
16666 }
16667 {
16668 if (temp2)
16669 delete arg2;
16670 }
16671 return NULL;
16672 }
16673
16674
16675 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj;
16677 wxString *arg1 = 0 ;
16678 wxString const &arg2_defvalue = wxPyART_OTHER ;
16679 wxString *arg2 = (wxString *) &arg2_defvalue ;
16680 wxSize const &arg3_defvalue = wxDefaultSize ;
16681 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16682 wxIcon result;
16683 bool temp1 = false ;
16684 bool temp2 = false ;
16685 wxSize temp3 ;
16686 PyObject * obj0 = 0 ;
16687 PyObject * obj1 = 0 ;
16688 PyObject * obj2 = 0 ;
16689 char *kwnames[] = {
16690 (char *) "id",(char *) "client",(char *) "size", NULL
16691 };
16692
16693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16694 {
16695 arg1 = wxString_in_helper(obj0);
16696 if (arg1 == NULL) SWIG_fail;
16697 temp1 = true;
16698 }
16699 if (obj1) {
16700 {
16701 arg2 = wxString_in_helper(obj1);
16702 if (arg2 == NULL) SWIG_fail;
16703 temp2 = true;
16704 }
16705 }
16706 if (obj2) {
16707 {
16708 arg3 = &temp3;
16709 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16710 }
16711 }
16712 {
16713 if (!wxPyCheckForApp()) SWIG_fail;
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16716
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 {
16721 wxIcon * resultptr;
16722 resultptr = new wxIcon((wxIcon &)(result));
16723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16724 }
16725 {
16726 if (temp1)
16727 delete arg1;
16728 }
16729 {
16730 if (temp2)
16731 delete arg2;
16732 }
16733 return resultobj;
16734 fail:
16735 {
16736 if (temp1)
16737 delete arg1;
16738 }
16739 {
16740 if (temp2)
16741 delete arg2;
16742 }
16743 return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxString *arg1 = 0 ;
16750 bool arg2 = (bool) false ;
16751 wxSize result;
16752 bool temp1 = false ;
16753 PyObject * obj0 = 0 ;
16754 PyObject * obj1 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "client",(char *) "platform_dependent", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16760 {
16761 arg1 = wxString_in_helper(obj0);
16762 if (arg1 == NULL) SWIG_fail;
16763 temp1 = true;
16764 }
16765 if (obj1) {
16766 {
16767 arg2 = (bool)(SWIG_As_bool(obj1));
16768 if (SWIG_arg_fail(2)) SWIG_fail;
16769 }
16770 }
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16774
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 wxSize * resultptr;
16780 resultptr = new wxSize((wxSize &)(result));
16781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16782 }
16783 {
16784 if (temp1)
16785 delete arg1;
16786 }
16787 return resultobj;
16788 fail:
16789 {
16790 if (temp1)
16791 delete arg1;
16792 }
16793 return NULL;
16794 }
16795
16796
16797 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj;
16799 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16800 PyObject * obj0 = 0 ;
16801 char *kwnames[] = {
16802 (char *) "self", NULL
16803 };
16804
16805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16807 if (SWIG_arg_fail(1)) SWIG_fail;
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 wxPyArtProvider_Destroy(arg1);
16811
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 Py_INCREF(Py_None); resultobj = Py_None;
16816 return resultobj;
16817 fail:
16818 return NULL;
16819 }
16820
16821
16822 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16823 PyObject *obj;
16824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16825 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16826 Py_INCREF(obj);
16827 return Py_BuildValue((char *)"");
16828 }
16829 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16832 PyObject * obj0 = 0 ;
16833 char *kwnames[] = {
16834 (char *) "self", NULL
16835 };
16836
16837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16839 if (SWIG_arg_fail(1)) SWIG_fail;
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 delete arg1;
16843
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 Py_INCREF(Py_None); resultobj = Py_None;
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj;
16856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16857 wxConfigBase *result;
16858 PyObject * obj0 = 0 ;
16859 char *kwnames[] = {
16860 (char *) "config", NULL
16861 };
16862
16863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16865 if (SWIG_arg_fail(1)) SWIG_fail;
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16869
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj;
16882 bool arg1 = (bool) true ;
16883 wxConfigBase *result;
16884 PyObject * obj0 = 0 ;
16885 char *kwnames[] = {
16886 (char *) "createOnDemand", NULL
16887 };
16888
16889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16890 if (obj0) {
16891 {
16892 arg1 = (bool)(SWIG_As_bool(obj0));
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 }
16895 }
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16899
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj;
16912 wxConfigBase *result;
16913 char *kwnames[] = {
16914 NULL
16915 };
16916
16917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = (wxConfigBase *)wxConfigBase::Create();
16921
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj;
16934 char *kwnames[] = {
16935 NULL
16936 };
16937
16938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 wxConfigBase::DontCreateOnDemand();
16942
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 Py_INCREF(Py_None); resultobj = Py_None;
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj;
16955 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16956 wxString *arg2 = 0 ;
16957 bool temp2 = false ;
16958 PyObject * obj0 = 0 ;
16959 PyObject * obj1 = 0 ;
16960 char *kwnames[] = {
16961 (char *) "self",(char *) "path", NULL
16962 };
16963
16964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16966 if (SWIG_arg_fail(1)) SWIG_fail;
16967 {
16968 arg2 = wxString_in_helper(obj1);
16969 if (arg2 == NULL) SWIG_fail;
16970 temp2 = true;
16971 }
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 (arg1)->SetPath((wxString const &)*arg2);
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 Py_INCREF(Py_None); resultobj = Py_None;
16980 {
16981 if (temp2)
16982 delete arg2;
16983 }
16984 return resultobj;
16985 fail:
16986 {
16987 if (temp2)
16988 delete arg2;
16989 }
16990 return NULL;
16991 }
16992
16993
16994 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj;
16996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16997 wxString *result;
16998 PyObject * obj0 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "self", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17005 if (SWIG_arg_fail(1)) SWIG_fail;
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 {
17009 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17010 result = (wxString *) &_result_ref;
17011 }
17012
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 {
17017 #if wxUSE_UNICODE
17018 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17019 #else
17020 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17021 #endif
17022 }
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj;
17031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17032 PyObject *result;
17033 PyObject * obj0 = 0 ;
17034 char *kwnames[] = {
17035 (char *) "self", NULL
17036 };
17037
17038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17040 if (SWIG_arg_fail(1)) SWIG_fail;
17041 {
17042 PyThreadState* __tstate = wxPyBeginAllowThreads();
17043 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17044
17045 wxPyEndAllowThreads(__tstate);
17046 if (PyErr_Occurred()) SWIG_fail;
17047 }
17048 resultobj = result;
17049 return resultobj;
17050 fail:
17051 return NULL;
17052 }
17053
17054
17055 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17056 PyObject *resultobj;
17057 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17058 long arg2 ;
17059 PyObject *result;
17060 PyObject * obj0 = 0 ;
17061 PyObject * obj1 = 0 ;
17062 char *kwnames[] = {
17063 (char *) "self",(char *) "index", NULL
17064 };
17065
17066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17068 if (SWIG_arg_fail(1)) SWIG_fail;
17069 {
17070 arg2 = (long)(SWIG_As_long(obj1));
17071 if (SWIG_arg_fail(2)) SWIG_fail;
17072 }
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17076
17077 wxPyEndAllowThreads(__tstate);
17078 if (PyErr_Occurred()) SWIG_fail;
17079 }
17080 resultobj = result;
17081 return resultobj;
17082 fail:
17083 return NULL;
17084 }
17085
17086
17087 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17088 PyObject *resultobj;
17089 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17090 PyObject *result;
17091 PyObject * obj0 = 0 ;
17092 char *kwnames[] = {
17093 (char *) "self", NULL
17094 };
17095
17096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17098 if (SWIG_arg_fail(1)) SWIG_fail;
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17102
17103 wxPyEndAllowThreads(__tstate);
17104 if (PyErr_Occurred()) SWIG_fail;
17105 }
17106 resultobj = result;
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj;
17115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17116 long arg2 ;
17117 PyObject *result;
17118 PyObject * obj0 = 0 ;
17119 PyObject * obj1 = 0 ;
17120 char *kwnames[] = {
17121 (char *) "self",(char *) "index", NULL
17122 };
17123
17124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17126 if (SWIG_arg_fail(1)) SWIG_fail;
17127 {
17128 arg2 = (long)(SWIG_As_long(obj1));
17129 if (SWIG_arg_fail(2)) SWIG_fail;
17130 }
17131 {
17132 PyThreadState* __tstate = wxPyBeginAllowThreads();
17133 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17134
17135 wxPyEndAllowThreads(__tstate);
17136 if (PyErr_Occurred()) SWIG_fail;
17137 }
17138 resultobj = result;
17139 return resultobj;
17140 fail:
17141 return NULL;
17142 }
17143
17144
17145 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17146 PyObject *resultobj;
17147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17148 bool arg2 = (bool) false ;
17149 size_t result;
17150 PyObject * obj0 = 0 ;
17151 PyObject * obj1 = 0 ;
17152 char *kwnames[] = {
17153 (char *) "self",(char *) "recursive", NULL
17154 };
17155
17156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17158 if (SWIG_arg_fail(1)) SWIG_fail;
17159 if (obj1) {
17160 {
17161 arg2 = (bool)(SWIG_As_bool(obj1));
17162 if (SWIG_arg_fail(2)) SWIG_fail;
17163 }
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 {
17173 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17174 }
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17184 bool arg2 = (bool) false ;
17185 size_t result;
17186 PyObject * obj0 = 0 ;
17187 PyObject * obj1 = 0 ;
17188 char *kwnames[] = {
17189 (char *) "self",(char *) "recursive", NULL
17190 };
17191
17192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17194 if (SWIG_arg_fail(1)) SWIG_fail;
17195 if (obj1) {
17196 {
17197 arg2 = (bool)(SWIG_As_bool(obj1));
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 }
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17204
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 {
17209 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17210 }
17211 return resultobj;
17212 fail:
17213 return NULL;
17214 }
17215
17216
17217 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj;
17219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17220 wxString *arg2 = 0 ;
17221 bool result;
17222 bool temp2 = false ;
17223 PyObject * obj0 = 0 ;
17224 PyObject * obj1 = 0 ;
17225 char *kwnames[] = {
17226 (char *) "self",(char *) "name", NULL
17227 };
17228
17229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17231 if (SWIG_arg_fail(1)) SWIG_fail;
17232 {
17233 arg2 = wxString_in_helper(obj1);
17234 if (arg2 == NULL) SWIG_fail;
17235 temp2 = true;
17236 }
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17240
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17246 }
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 return resultobj;
17252 fail:
17253 {
17254 if (temp2)
17255 delete arg2;
17256 }
17257 return NULL;
17258 }
17259
17260
17261 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj;
17263 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17264 wxString *arg2 = 0 ;
17265 bool result;
17266 bool temp2 = false ;
17267 PyObject * obj0 = 0 ;
17268 PyObject * obj1 = 0 ;
17269 char *kwnames[] = {
17270 (char *) "self",(char *) "name", NULL
17271 };
17272
17273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17275 if (SWIG_arg_fail(1)) SWIG_fail;
17276 {
17277 arg2 = wxString_in_helper(obj1);
17278 if (arg2 == NULL) SWIG_fail;
17279 temp2 = true;
17280 }
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17284
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 {
17289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17290 }
17291 {
17292 if (temp2)
17293 delete arg2;
17294 }
17295 return resultobj;
17296 fail:
17297 {
17298 if (temp2)
17299 delete arg2;
17300 }
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj;
17307 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17308 wxString *arg2 = 0 ;
17309 bool result;
17310 bool temp2 = false ;
17311 PyObject * obj0 = 0 ;
17312 PyObject * obj1 = 0 ;
17313 char *kwnames[] = {
17314 (char *) "self",(char *) "name", NULL
17315 };
17316
17317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17319 if (SWIG_arg_fail(1)) SWIG_fail;
17320 {
17321 arg2 = wxString_in_helper(obj1);
17322 if (arg2 == NULL) SWIG_fail;
17323 temp2 = true;
17324 }
17325 {
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17328
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 {
17333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17334 }
17335 {
17336 if (temp2)
17337 delete arg2;
17338 }
17339 return resultobj;
17340 fail:
17341 {
17342 if (temp2)
17343 delete arg2;
17344 }
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj;
17351 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17352 wxString *arg2 = 0 ;
17353 wxConfigBase::EntryType result;
17354 bool temp2 = false ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self",(char *) "name", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 {
17365 arg2 = wxString_in_helper(obj1);
17366 if (arg2 == NULL) SWIG_fail;
17367 temp2 = true;
17368 }
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17372
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 resultobj = SWIG_From_int((result));
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 return resultobj;
17382 fail:
17383 {
17384 if (temp2)
17385 delete arg2;
17386 }
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17394 wxString *arg2 = 0 ;
17395 wxString const &arg3_defvalue = wxPyEmptyString ;
17396 wxString *arg3 = (wxString *) &arg3_defvalue ;
17397 wxString result;
17398 bool temp2 = false ;
17399 bool temp3 = false ;
17400 PyObject * obj0 = 0 ;
17401 PyObject * obj1 = 0 ;
17402 PyObject * obj2 = 0 ;
17403 char *kwnames[] = {
17404 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17405 };
17406
17407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17409 if (SWIG_arg_fail(1)) SWIG_fail;
17410 {
17411 arg2 = wxString_in_helper(obj1);
17412 if (arg2 == NULL) SWIG_fail;
17413 temp2 = true;
17414 }
17415 if (obj2) {
17416 {
17417 arg3 = wxString_in_helper(obj2);
17418 if (arg3 == NULL) SWIG_fail;
17419 temp3 = true;
17420 }
17421 }
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17425
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 #if wxUSE_UNICODE
17431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17432 #else
17433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17434 #endif
17435 }
17436 {
17437 if (temp2)
17438 delete arg2;
17439 }
17440 {
17441 if (temp3)
17442 delete arg3;
17443 }
17444 return resultobj;
17445 fail:
17446 {
17447 if (temp2)
17448 delete arg2;
17449 }
17450 {
17451 if (temp3)
17452 delete arg3;
17453 }
17454 return NULL;
17455 }
17456
17457
17458 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17459 PyObject *resultobj;
17460 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17461 wxString *arg2 = 0 ;
17462 long arg3 = (long) 0 ;
17463 long result;
17464 bool temp2 = false ;
17465 PyObject * obj0 = 0 ;
17466 PyObject * obj1 = 0 ;
17467 PyObject * obj2 = 0 ;
17468 char *kwnames[] = {
17469 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17470 };
17471
17472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17474 if (SWIG_arg_fail(1)) SWIG_fail;
17475 {
17476 arg2 = wxString_in_helper(obj1);
17477 if (arg2 == NULL) SWIG_fail;
17478 temp2 = true;
17479 }
17480 if (obj2) {
17481 {
17482 arg3 = (long)(SWIG_As_long(obj2));
17483 if (SWIG_arg_fail(3)) SWIG_fail;
17484 }
17485 }
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17489
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = SWIG_From_long((long)(result));
17495 }
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 return resultobj;
17501 fail:
17502 {
17503 if (temp2)
17504 delete arg2;
17505 }
17506 return NULL;
17507 }
17508
17509
17510 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17511 PyObject *resultobj;
17512 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17513 wxString *arg2 = 0 ;
17514 double arg3 = (double) 0.0 ;
17515 double result;
17516 bool temp2 = false ;
17517 PyObject * obj0 = 0 ;
17518 PyObject * obj1 = 0 ;
17519 PyObject * obj2 = 0 ;
17520 char *kwnames[] = {
17521 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17522 };
17523
17524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17526 if (SWIG_arg_fail(1)) SWIG_fail;
17527 {
17528 arg2 = wxString_in_helper(obj1);
17529 if (arg2 == NULL) SWIG_fail;
17530 temp2 = true;
17531 }
17532 if (obj2) {
17533 {
17534 arg3 = (double)(SWIG_As_double(obj2));
17535 if (SWIG_arg_fail(3)) SWIG_fail;
17536 }
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17541
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 {
17546 resultobj = SWIG_From_double((double)(result));
17547 }
17548 {
17549 if (temp2)
17550 delete arg2;
17551 }
17552 return resultobj;
17553 fail:
17554 {
17555 if (temp2)
17556 delete arg2;
17557 }
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17565 wxString *arg2 = 0 ;
17566 bool arg3 = (bool) false ;
17567 bool result;
17568 bool temp2 = false ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 {
17580 arg2 = wxString_in_helper(obj1);
17581 if (arg2 == NULL) SWIG_fail;
17582 temp2 = true;
17583 }
17584 if (obj2) {
17585 {
17586 arg3 = (bool)(SWIG_As_bool(obj2));
17587 if (SWIG_arg_fail(3)) SWIG_fail;
17588 }
17589 }
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17599 }
17600 {
17601 if (temp2)
17602 delete arg2;
17603 }
17604 return resultobj;
17605 fail:
17606 {
17607 if (temp2)
17608 delete arg2;
17609 }
17610 return NULL;
17611 }
17612
17613
17614 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17615 PyObject *resultobj;
17616 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17617 wxString *arg2 = 0 ;
17618 wxString *arg3 = 0 ;
17619 bool result;
17620 bool temp2 = false ;
17621 bool temp3 = false ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 PyObject * obj2 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "self",(char *) "key",(char *) "value", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 {
17633 arg2 = wxString_in_helper(obj1);
17634 if (arg2 == NULL) SWIG_fail;
17635 temp2 = true;
17636 }
17637 {
17638 arg3 = wxString_in_helper(obj2);
17639 if (arg3 == NULL) SWIG_fail;
17640 temp3 = true;
17641 }
17642 {
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17645
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17651 }
17652 {
17653 if (temp2)
17654 delete arg2;
17655 }
17656 {
17657 if (temp3)
17658 delete arg3;
17659 }
17660 return resultobj;
17661 fail:
17662 {
17663 if (temp2)
17664 delete arg2;
17665 }
17666 {
17667 if (temp3)
17668 delete arg3;
17669 }
17670 return NULL;
17671 }
17672
17673
17674 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17675 PyObject *resultobj;
17676 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17677 wxString *arg2 = 0 ;
17678 long arg3 ;
17679 bool result;
17680 bool temp2 = false ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 PyObject * obj2 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "self",(char *) "key",(char *) "value", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 {
17692 arg2 = wxString_in_helper(obj1);
17693 if (arg2 == NULL) SWIG_fail;
17694 temp2 = true;
17695 }
17696 {
17697 arg3 = (long)(SWIG_As_long(obj2));
17698 if (SWIG_arg_fail(3)) SWIG_fail;
17699 }
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17703
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 {
17708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17709 }
17710 {
17711 if (temp2)
17712 delete arg2;
17713 }
17714 return resultobj;
17715 fail:
17716 {
17717 if (temp2)
17718 delete arg2;
17719 }
17720 return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj;
17726 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17727 wxString *arg2 = 0 ;
17728 double arg3 ;
17729 bool result;
17730 bool temp2 = false ;
17731 PyObject * obj0 = 0 ;
17732 PyObject * obj1 = 0 ;
17733 PyObject * obj2 = 0 ;
17734 char *kwnames[] = {
17735 (char *) "self",(char *) "key",(char *) "value", NULL
17736 };
17737
17738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17740 if (SWIG_arg_fail(1)) SWIG_fail;
17741 {
17742 arg2 = wxString_in_helper(obj1);
17743 if (arg2 == NULL) SWIG_fail;
17744 temp2 = true;
17745 }
17746 {
17747 arg3 = (double)(SWIG_As_double(obj2));
17748 if (SWIG_arg_fail(3)) SWIG_fail;
17749 }
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17753
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17759 }
17760 {
17761 if (temp2)
17762 delete arg2;
17763 }
17764 return resultobj;
17765 fail:
17766 {
17767 if (temp2)
17768 delete arg2;
17769 }
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17777 wxString *arg2 = 0 ;
17778 bool arg3 ;
17779 bool result;
17780 bool temp2 = false ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 PyObject * obj2 = 0 ;
17784 char *kwnames[] = {
17785 (char *) "self",(char *) "key",(char *) "value", NULL
17786 };
17787
17788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17790 if (SWIG_arg_fail(1)) SWIG_fail;
17791 {
17792 arg2 = wxString_in_helper(obj1);
17793 if (arg2 == NULL) SWIG_fail;
17794 temp2 = true;
17795 }
17796 {
17797 arg3 = (bool)(SWIG_As_bool(obj2));
17798 if (SWIG_arg_fail(3)) SWIG_fail;
17799 }
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17803
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 {
17808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17809 }
17810 {
17811 if (temp2)
17812 delete arg2;
17813 }
17814 return resultobj;
17815 fail:
17816 {
17817 if (temp2)
17818 delete arg2;
17819 }
17820 return NULL;
17821 }
17822
17823
17824 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj;
17826 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17827 bool arg2 = (bool) false ;
17828 bool result;
17829 PyObject * obj0 = 0 ;
17830 PyObject * obj1 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self",(char *) "currentOnly", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 if (obj1) {
17839 {
17840 arg2 = (bool)(SWIG_As_bool(obj1));
17841 if (SWIG_arg_fail(2)) SWIG_fail;
17842 }
17843 }
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (bool)(arg1)->Flush(arg2);
17847
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17853 }
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17861 PyObject *resultobj;
17862 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17863 wxString *arg2 = 0 ;
17864 wxString *arg3 = 0 ;
17865 bool result;
17866 bool temp2 = false ;
17867 bool temp3 = false ;
17868 PyObject * obj0 = 0 ;
17869 PyObject * obj1 = 0 ;
17870 PyObject * obj2 = 0 ;
17871 char *kwnames[] = {
17872 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17873 };
17874
17875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17877 if (SWIG_arg_fail(1)) SWIG_fail;
17878 {
17879 arg2 = wxString_in_helper(obj1);
17880 if (arg2 == NULL) SWIG_fail;
17881 temp2 = true;
17882 }
17883 {
17884 arg3 = wxString_in_helper(obj2);
17885 if (arg3 == NULL) SWIG_fail;
17886 temp3 = true;
17887 }
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17891
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 {
17899 if (temp2)
17900 delete arg2;
17901 }
17902 {
17903 if (temp3)
17904 delete arg3;
17905 }
17906 return resultobj;
17907 fail:
17908 {
17909 if (temp2)
17910 delete arg2;
17911 }
17912 {
17913 if (temp3)
17914 delete arg3;
17915 }
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17923 wxString *arg2 = 0 ;
17924 wxString *arg3 = 0 ;
17925 bool result;
17926 bool temp2 = false ;
17927 bool temp3 = false ;
17928 PyObject * obj0 = 0 ;
17929 PyObject * obj1 = 0 ;
17930 PyObject * obj2 = 0 ;
17931 char *kwnames[] = {
17932 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17933 };
17934
17935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17937 if (SWIG_arg_fail(1)) SWIG_fail;
17938 {
17939 arg2 = wxString_in_helper(obj1);
17940 if (arg2 == NULL) SWIG_fail;
17941 temp2 = true;
17942 }
17943 {
17944 arg3 = wxString_in_helper(obj2);
17945 if (arg3 == NULL) SWIG_fail;
17946 temp3 = true;
17947 }
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17951
17952 wxPyEndAllowThreads(__tstate);
17953 if (PyErr_Occurred()) SWIG_fail;
17954 }
17955 {
17956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17957 }
17958 {
17959 if (temp2)
17960 delete arg2;
17961 }
17962 {
17963 if (temp3)
17964 delete arg3;
17965 }
17966 return resultobj;
17967 fail:
17968 {
17969 if (temp2)
17970 delete arg2;
17971 }
17972 {
17973 if (temp3)
17974 delete arg3;
17975 }
17976 return NULL;
17977 }
17978
17979
17980 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj;
17982 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17983 wxString *arg2 = 0 ;
17984 bool arg3 = (bool) true ;
17985 bool result;
17986 bool temp2 = false ;
17987 PyObject * obj0 = 0 ;
17988 PyObject * obj1 = 0 ;
17989 PyObject * obj2 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 arg2 = wxString_in_helper(obj1);
17999 if (arg2 == NULL) SWIG_fail;
18000 temp2 = true;
18001 }
18002 if (obj2) {
18003 {
18004 arg3 = (bool)(SWIG_As_bool(obj2));
18005 if (SWIG_arg_fail(3)) SWIG_fail;
18006 }
18007 }
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 {
18016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18017 }
18018 {
18019 if (temp2)
18020 delete arg2;
18021 }
18022 return resultobj;
18023 fail:
18024 {
18025 if (temp2)
18026 delete arg2;
18027 }
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj;
18034 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18035 wxString *arg2 = 0 ;
18036 bool result;
18037 bool temp2 = false ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 char *kwnames[] = {
18041 (char *) "self",(char *) "key", NULL
18042 };
18043
18044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18046 if (SWIG_arg_fail(1)) SWIG_fail;
18047 {
18048 arg2 = wxString_in_helper(obj1);
18049 if (arg2 == NULL) SWIG_fail;
18050 temp2 = true;
18051 }
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18055
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 {
18060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18061 }
18062 {
18063 if (temp2)
18064 delete arg2;
18065 }
18066 return resultobj;
18067 fail:
18068 {
18069 if (temp2)
18070 delete arg2;
18071 }
18072 return NULL;
18073 }
18074
18075
18076 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj;
18078 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18079 bool result;
18080 PyObject * obj0 = 0 ;
18081 char *kwnames[] = {
18082 (char *) "self", NULL
18083 };
18084
18085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18087 if (SWIG_arg_fail(1)) SWIG_fail;
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (bool)(arg1)->DeleteAll();
18091
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 {
18096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18097 }
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18105 PyObject *resultobj;
18106 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18107 bool arg2 = (bool) true ;
18108 PyObject * obj0 = 0 ;
18109 PyObject * obj1 = 0 ;
18110 char *kwnames[] = {
18111 (char *) "self",(char *) "doIt", NULL
18112 };
18113
18114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18116 if (SWIG_arg_fail(1)) SWIG_fail;
18117 if (obj1) {
18118 {
18119 arg2 = (bool)(SWIG_As_bool(obj1));
18120 if (SWIG_arg_fail(2)) SWIG_fail;
18121 }
18122 }
18123 {
18124 PyThreadState* __tstate = wxPyBeginAllowThreads();
18125 (arg1)->SetExpandEnvVars(arg2);
18126
18127 wxPyEndAllowThreads(__tstate);
18128 if (PyErr_Occurred()) SWIG_fail;
18129 }
18130 Py_INCREF(Py_None); resultobj = Py_None;
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj;
18139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18140 bool result;
18141 PyObject * obj0 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18152
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 {
18157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18158 }
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj;
18167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18168 bool arg2 = (bool) true ;
18169 PyObject * obj0 = 0 ;
18170 PyObject * obj1 = 0 ;
18171 char *kwnames[] = {
18172 (char *) "self",(char *) "doIt", NULL
18173 };
18174
18175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18177 if (SWIG_arg_fail(1)) SWIG_fail;
18178 if (obj1) {
18179 {
18180 arg2 = (bool)(SWIG_As_bool(obj1));
18181 if (SWIG_arg_fail(2)) SWIG_fail;
18182 }
18183 }
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 (arg1)->SetRecordDefaults(arg2);
18187
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 Py_INCREF(Py_None); resultobj = Py_None;
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18199 PyObject *resultobj;
18200 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18201 bool result;
18202 PyObject * obj0 = 0 ;
18203 char *kwnames[] = {
18204 (char *) "self", NULL
18205 };
18206
18207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18209 if (SWIG_arg_fail(1)) SWIG_fail;
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18213
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 {
18218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18219 }
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj;
18228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18229 wxString *arg2 = 0 ;
18230 wxString result;
18231 bool temp2 = false ;
18232 PyObject * obj0 = 0 ;
18233 PyObject * obj1 = 0 ;
18234 char *kwnames[] = {
18235 (char *) "self",(char *) "str", NULL
18236 };
18237
18238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18240 if (SWIG_arg_fail(1)) SWIG_fail;
18241 {
18242 arg2 = wxString_in_helper(obj1);
18243 if (arg2 == NULL) SWIG_fail;
18244 temp2 = true;
18245 }
18246 {
18247 PyThreadState* __tstate = wxPyBeginAllowThreads();
18248 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18249
18250 wxPyEndAllowThreads(__tstate);
18251 if (PyErr_Occurred()) SWIG_fail;
18252 }
18253 {
18254 #if wxUSE_UNICODE
18255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18256 #else
18257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18258 #endif
18259 }
18260 {
18261 if (temp2)
18262 delete arg2;
18263 }
18264 return resultobj;
18265 fail:
18266 {
18267 if (temp2)
18268 delete arg2;
18269 }
18270 return NULL;
18271 }
18272
18273
18274 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18275 PyObject *resultobj;
18276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18277 wxString result;
18278 PyObject * obj0 = 0 ;
18279 char *kwnames[] = {
18280 (char *) "self", NULL
18281 };
18282
18283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18285 if (SWIG_arg_fail(1)) SWIG_fail;
18286 {
18287 PyThreadState* __tstate = wxPyBeginAllowThreads();
18288 result = ((wxConfigBase const *)arg1)->GetAppName();
18289
18290 wxPyEndAllowThreads(__tstate);
18291 if (PyErr_Occurred()) SWIG_fail;
18292 }
18293 {
18294 #if wxUSE_UNICODE
18295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18296 #else
18297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18298 #endif
18299 }
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18309 wxString result;
18310 PyObject * obj0 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 result = ((wxConfigBase const *)arg1)->GetVendorName();
18321
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 {
18326 #if wxUSE_UNICODE
18327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18328 #else
18329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18330 #endif
18331 }
18332 return resultobj;
18333 fail:
18334 return NULL;
18335 }
18336
18337
18338 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18339 PyObject *resultobj;
18340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18341 wxString *arg2 = 0 ;
18342 bool temp2 = false ;
18343 PyObject * obj0 = 0 ;
18344 PyObject * obj1 = 0 ;
18345 char *kwnames[] = {
18346 (char *) "self",(char *) "appName", NULL
18347 };
18348
18349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18351 if (SWIG_arg_fail(1)) SWIG_fail;
18352 {
18353 arg2 = wxString_in_helper(obj1);
18354 if (arg2 == NULL) SWIG_fail;
18355 temp2 = true;
18356 }
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 (arg1)->SetAppName((wxString const &)*arg2);
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 Py_INCREF(Py_None); resultobj = Py_None;
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 return resultobj;
18370 fail:
18371 {
18372 if (temp2)
18373 delete arg2;
18374 }
18375 return NULL;
18376 }
18377
18378
18379 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18380 PyObject *resultobj;
18381 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18382 wxString *arg2 = 0 ;
18383 bool temp2 = false ;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 char *kwnames[] = {
18387 (char *) "self",(char *) "vendorName", NULL
18388 };
18389
18390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18392 if (SWIG_arg_fail(1)) SWIG_fail;
18393 {
18394 arg2 = wxString_in_helper(obj1);
18395 if (arg2 == NULL) SWIG_fail;
18396 temp2 = true;
18397 }
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 (arg1)->SetVendorName((wxString const &)*arg2);
18401
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 Py_INCREF(Py_None); resultobj = Py_None;
18406 {
18407 if (temp2)
18408 delete arg2;
18409 }
18410 return resultobj;
18411 fail:
18412 {
18413 if (temp2)
18414 delete arg2;
18415 }
18416 return NULL;
18417 }
18418
18419
18420 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18423 long arg2 ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 char *kwnames[] = {
18427 (char *) "self",(char *) "style", NULL
18428 };
18429
18430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18432 if (SWIG_arg_fail(1)) SWIG_fail;
18433 {
18434 arg2 = (long)(SWIG_As_long(obj1));
18435 if (SWIG_arg_fail(2)) SWIG_fail;
18436 }
18437 {
18438 PyThreadState* __tstate = wxPyBeginAllowThreads();
18439 (arg1)->SetStyle(arg2);
18440
18441 wxPyEndAllowThreads(__tstate);
18442 if (PyErr_Occurred()) SWIG_fail;
18443 }
18444 Py_INCREF(Py_None); resultobj = Py_None;
18445 return resultobj;
18446 fail:
18447 return NULL;
18448 }
18449
18450
18451 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18452 PyObject *resultobj;
18453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18454 long result;
18455 PyObject * obj0 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 PyThreadState* __tstate = wxPyBeginAllowThreads();
18465 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18466
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 resultobj = SWIG_From_long((long)(result));
18472 }
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18480 PyObject *obj;
18481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18482 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18483 Py_INCREF(obj);
18484 return Py_BuildValue((char *)"");
18485 }
18486 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18487 PyObject *resultobj;
18488 wxString const &arg1_defvalue = wxPyEmptyString ;
18489 wxString *arg1 = (wxString *) &arg1_defvalue ;
18490 wxString const &arg2_defvalue = wxPyEmptyString ;
18491 wxString *arg2 = (wxString *) &arg2_defvalue ;
18492 wxString const &arg3_defvalue = wxPyEmptyString ;
18493 wxString *arg3 = (wxString *) &arg3_defvalue ;
18494 wxString const &arg4_defvalue = wxPyEmptyString ;
18495 wxString *arg4 = (wxString *) &arg4_defvalue ;
18496 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18497 wxConfig *result;
18498 bool temp1 = false ;
18499 bool temp2 = false ;
18500 bool temp3 = false ;
18501 bool temp4 = false ;
18502 PyObject * obj0 = 0 ;
18503 PyObject * obj1 = 0 ;
18504 PyObject * obj2 = 0 ;
18505 PyObject * obj3 = 0 ;
18506 PyObject * obj4 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18512 if (obj0) {
18513 {
18514 arg1 = wxString_in_helper(obj0);
18515 if (arg1 == NULL) SWIG_fail;
18516 temp1 = true;
18517 }
18518 }
18519 if (obj1) {
18520 {
18521 arg2 = wxString_in_helper(obj1);
18522 if (arg2 == NULL) SWIG_fail;
18523 temp2 = true;
18524 }
18525 }
18526 if (obj2) {
18527 {
18528 arg3 = wxString_in_helper(obj2);
18529 if (arg3 == NULL) SWIG_fail;
18530 temp3 = true;
18531 }
18532 }
18533 if (obj3) {
18534 {
18535 arg4 = wxString_in_helper(obj3);
18536 if (arg4 == NULL) SWIG_fail;
18537 temp4 = true;
18538 }
18539 }
18540 if (obj4) {
18541 {
18542 arg5 = (long)(SWIG_As_long(obj4));
18543 if (SWIG_arg_fail(5)) SWIG_fail;
18544 }
18545 }
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18549
18550 wxPyEndAllowThreads(__tstate);
18551 if (PyErr_Occurred()) SWIG_fail;
18552 }
18553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18554 {
18555 if (temp1)
18556 delete arg1;
18557 }
18558 {
18559 if (temp2)
18560 delete arg2;
18561 }
18562 {
18563 if (temp3)
18564 delete arg3;
18565 }
18566 {
18567 if (temp4)
18568 delete arg4;
18569 }
18570 return resultobj;
18571 fail:
18572 {
18573 if (temp1)
18574 delete arg1;
18575 }
18576 {
18577 if (temp2)
18578 delete arg2;
18579 }
18580 {
18581 if (temp3)
18582 delete arg3;
18583 }
18584 {
18585 if (temp4)
18586 delete arg4;
18587 }
18588 return NULL;
18589 }
18590
18591
18592 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj;
18594 wxConfig *arg1 = (wxConfig *) 0 ;
18595 PyObject * obj0 = 0 ;
18596 char *kwnames[] = {
18597 (char *) "self", NULL
18598 };
18599
18600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18602 if (SWIG_arg_fail(1)) SWIG_fail;
18603 {
18604 PyThreadState* __tstate = wxPyBeginAllowThreads();
18605 delete arg1;
18606
18607 wxPyEndAllowThreads(__tstate);
18608 if (PyErr_Occurred()) SWIG_fail;
18609 }
18610 Py_INCREF(Py_None); resultobj = Py_None;
18611 return resultobj;
18612 fail:
18613 return NULL;
18614 }
18615
18616
18617 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18618 PyObject *obj;
18619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18620 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18621 Py_INCREF(obj);
18622 return Py_BuildValue((char *)"");
18623 }
18624 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18625 PyObject *resultobj;
18626 wxString const &arg1_defvalue = wxPyEmptyString ;
18627 wxString *arg1 = (wxString *) &arg1_defvalue ;
18628 wxString const &arg2_defvalue = wxPyEmptyString ;
18629 wxString *arg2 = (wxString *) &arg2_defvalue ;
18630 wxString const &arg3_defvalue = wxPyEmptyString ;
18631 wxString *arg3 = (wxString *) &arg3_defvalue ;
18632 wxString const &arg4_defvalue = wxPyEmptyString ;
18633 wxString *arg4 = (wxString *) &arg4_defvalue ;
18634 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18635 wxFileConfig *result;
18636 bool temp1 = false ;
18637 bool temp2 = false ;
18638 bool temp3 = false ;
18639 bool temp4 = false ;
18640 PyObject * obj0 = 0 ;
18641 PyObject * obj1 = 0 ;
18642 PyObject * obj2 = 0 ;
18643 PyObject * obj3 = 0 ;
18644 PyObject * obj4 = 0 ;
18645 char *kwnames[] = {
18646 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18647 };
18648
18649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18650 if (obj0) {
18651 {
18652 arg1 = wxString_in_helper(obj0);
18653 if (arg1 == NULL) SWIG_fail;
18654 temp1 = true;
18655 }
18656 }
18657 if (obj1) {
18658 {
18659 arg2 = wxString_in_helper(obj1);
18660 if (arg2 == NULL) SWIG_fail;
18661 temp2 = true;
18662 }
18663 }
18664 if (obj2) {
18665 {
18666 arg3 = wxString_in_helper(obj2);
18667 if (arg3 == NULL) SWIG_fail;
18668 temp3 = true;
18669 }
18670 }
18671 if (obj3) {
18672 {
18673 arg4 = wxString_in_helper(obj3);
18674 if (arg4 == NULL) SWIG_fail;
18675 temp4 = true;
18676 }
18677 }
18678 if (obj4) {
18679 {
18680 arg5 = (long)(SWIG_As_long(obj4));
18681 if (SWIG_arg_fail(5)) SWIG_fail;
18682 }
18683 }
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18692 {
18693 if (temp1)
18694 delete arg1;
18695 }
18696 {
18697 if (temp2)
18698 delete arg2;
18699 }
18700 {
18701 if (temp3)
18702 delete arg3;
18703 }
18704 {
18705 if (temp4)
18706 delete arg4;
18707 }
18708 return resultobj;
18709 fail:
18710 {
18711 if (temp1)
18712 delete arg1;
18713 }
18714 {
18715 if (temp2)
18716 delete arg2;
18717 }
18718 {
18719 if (temp3)
18720 delete arg3;
18721 }
18722 {
18723 if (temp4)
18724 delete arg4;
18725 }
18726 return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18733 PyObject * obj0 = 0 ;
18734 char *kwnames[] = {
18735 (char *) "self", NULL
18736 };
18737
18738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18740 if (SWIG_arg_fail(1)) SWIG_fail;
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 delete arg1;
18744
18745 wxPyEndAllowThreads(__tstate);
18746 if (PyErr_Occurred()) SWIG_fail;
18747 }
18748 Py_INCREF(Py_None); resultobj = Py_None;
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18756 PyObject *obj;
18757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18758 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18759 Py_INCREF(obj);
18760 return Py_BuildValue((char *)"");
18761 }
18762 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj;
18764 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18765 wxString *arg2 = 0 ;
18766 wxConfigPathChanger *result;
18767 bool temp2 = false ;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 char *kwnames[] = {
18771 (char *) "config",(char *) "entry", NULL
18772 };
18773
18774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18776 if (SWIG_arg_fail(1)) SWIG_fail;
18777 {
18778 arg2 = wxString_in_helper(obj1);
18779 if (arg2 == NULL) SWIG_fail;
18780 temp2 = true;
18781 }
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18785
18786 wxPyEndAllowThreads(__tstate);
18787 if (PyErr_Occurred()) SWIG_fail;
18788 }
18789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18790 {
18791 if (temp2)
18792 delete arg2;
18793 }
18794 return resultobj;
18795 fail:
18796 {
18797 if (temp2)
18798 delete arg2;
18799 }
18800 return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj;
18806 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18807 PyObject * obj0 = 0 ;
18808 char *kwnames[] = {
18809 (char *) "self", NULL
18810 };
18811
18812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18814 if (SWIG_arg_fail(1)) SWIG_fail;
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 delete arg1;
18818
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 Py_INCREF(Py_None); resultobj = Py_None;
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18830 PyObject *resultobj;
18831 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18832 wxString *result;
18833 PyObject * obj0 = 0 ;
18834 char *kwnames[] = {
18835 (char *) "self", NULL
18836 };
18837
18838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18840 if (SWIG_arg_fail(1)) SWIG_fail;
18841 {
18842 PyThreadState* __tstate = wxPyBeginAllowThreads();
18843 {
18844 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18845 result = (wxString *) &_result_ref;
18846 }
18847
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 {
18852 #if wxUSE_UNICODE
18853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18854 #else
18855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18856 #endif
18857 }
18858 return resultobj;
18859 fail:
18860 return NULL;
18861 }
18862
18863
18864 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18865 PyObject *obj;
18866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18867 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18868 Py_INCREF(obj);
18869 return Py_BuildValue((char *)"");
18870 }
18871 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj;
18873 wxString *arg1 = 0 ;
18874 wxString result;
18875 bool temp1 = false ;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "sz", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18882 {
18883 arg1 = wxString_in_helper(obj0);
18884 if (arg1 == NULL) SWIG_fail;
18885 temp1 = true;
18886 }
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 result = wxExpandEnvVars((wxString const &)*arg1);
18890
18891 wxPyEndAllowThreads(__tstate);
18892 if (PyErr_Occurred()) SWIG_fail;
18893 }
18894 {
18895 #if wxUSE_UNICODE
18896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18897 #else
18898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18899 #endif
18900 }
18901 {
18902 if (temp1)
18903 delete arg1;
18904 }
18905 return resultobj;
18906 fail:
18907 {
18908 if (temp1)
18909 delete arg1;
18910 }
18911 return NULL;
18912 }
18913
18914
18915 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18916 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18917 return 1;
18918 }
18919
18920
18921 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18922 PyObject *pyobj;
18923
18924 {
18925 #if wxUSE_UNICODE
18926 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18927 #else
18928 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18929 #endif
18930 }
18931 return pyobj;
18932 }
18933
18934
18935 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18936 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18937 return 1;
18938 }
18939
18940
18941 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18942 PyObject *pyobj;
18943
18944 {
18945 #if wxUSE_UNICODE
18946 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18947 #else
18948 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18949 #endif
18950 }
18951 return pyobj;
18952 }
18953
18954
18955 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18956 PyObject *resultobj;
18957 wxDateTime::Country arg1 ;
18958 PyObject * obj0 = 0 ;
18959 char *kwnames[] = {
18960 (char *) "country", NULL
18961 };
18962
18963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18964 {
18965 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18966 if (SWIG_arg_fail(1)) SWIG_fail;
18967 }
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18971
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 Py_INCREF(Py_None); resultobj = Py_None;
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj;
18984 wxDateTime::Country result;
18985 char *kwnames[] = {
18986 NULL
18987 };
18988
18989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18990 {
18991 PyThreadState* __tstate = wxPyBeginAllowThreads();
18992 result = (wxDateTime::Country)wxDateTime::GetCountry();
18993
18994 wxPyEndAllowThreads(__tstate);
18995 if (PyErr_Occurred()) SWIG_fail;
18996 }
18997 resultobj = SWIG_From_int((result));
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19005 PyObject *resultobj;
19006 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19007 bool result;
19008 PyObject * obj0 = 0 ;
19009 char *kwnames[] = {
19010 (char *) "country", NULL
19011 };
19012
19013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19014 if (obj0) {
19015 {
19016 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19017 if (SWIG_arg_fail(1)) SWIG_fail;
19018 }
19019 }
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19023
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 {
19028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19029 }
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj;
19038 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19039 int result;
19040 PyObject * obj0 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "cal", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19046 if (obj0) {
19047 {
19048 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 }
19051 }
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19055
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 {
19060 resultobj = SWIG_From_int((int)(result));
19061 }
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 int arg1 ;
19071 int result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "year", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19078 {
19079 arg1 = (int)(SWIG_As_int(obj0));
19080 if (SWIG_arg_fail(1)) SWIG_fail;
19081 }
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (int)wxDateTime::ConvertYearToBC(arg1);
19085
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 {
19090 resultobj = SWIG_From_int((int)(result));
19091 }
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj;
19100 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19101 wxDateTime::Month result;
19102 PyObject * obj0 = 0 ;
19103 char *kwnames[] = {
19104 (char *) "cal", NULL
19105 };
19106
19107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19108 if (obj0) {
19109 {
19110 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19111 if (SWIG_arg_fail(1)) SWIG_fail;
19112 }
19113 }
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19117
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = SWIG_From_int((result));
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19129 PyObject *resultobj;
19130 int arg1 = (int) wxDateTime::Inv_Year ;
19131 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19132 bool result;
19133 PyObject * obj0 = 0 ;
19134 PyObject * obj1 = 0 ;
19135 char *kwnames[] = {
19136 (char *) "year",(char *) "cal", NULL
19137 };
19138
19139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19140 if (obj0) {
19141 {
19142 arg1 = (int)(SWIG_As_int(obj0));
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 }
19145 }
19146 if (obj1) {
19147 {
19148 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19149 if (SWIG_arg_fail(2)) SWIG_fail;
19150 }
19151 }
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 {
19160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19161 }
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj;
19170 int arg1 = (int) wxDateTime::Inv_Year ;
19171 int result;
19172 PyObject * obj0 = 0 ;
19173 char *kwnames[] = {
19174 (char *) "year", NULL
19175 };
19176
19177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19178 if (obj0) {
19179 {
19180 arg1 = (int)(SWIG_As_int(obj0));
19181 if (SWIG_arg_fail(1)) SWIG_fail;
19182 }
19183 }
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 result = (int)wxDateTime::GetCentury(arg1);
19187
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 {
19192 resultobj = SWIG_From_int((int)(result));
19193 }
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19201 PyObject *resultobj;
19202 int arg1 ;
19203 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19204 int result;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char *kwnames[] = {
19208 (char *) "year",(char *) "cal", NULL
19209 };
19210
19211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19212 {
19213 arg1 = (int)(SWIG_As_int(obj0));
19214 if (SWIG_arg_fail(1)) SWIG_fail;
19215 }
19216 if (obj1) {
19217 {
19218 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19219 if (SWIG_arg_fail(2)) SWIG_fail;
19220 }
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = SWIG_From_int((int)(result));
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj;
19240 wxDateTime::Month arg1 ;
19241 int arg2 = (int) wxDateTime::Inv_Year ;
19242 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19243 int result;
19244 PyObject * obj0 = 0 ;
19245 PyObject * obj1 = 0 ;
19246 PyObject * obj2 = 0 ;
19247 char *kwnames[] = {
19248 (char *) "month",(char *) "year",(char *) "cal", NULL
19249 };
19250
19251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19252 {
19253 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19254 if (SWIG_arg_fail(1)) SWIG_fail;
19255 }
19256 if (obj1) {
19257 {
19258 arg2 = (int)(SWIG_As_int(obj1));
19259 if (SWIG_arg_fail(2)) SWIG_fail;
19260 }
19261 }
19262 if (obj2) {
19263 {
19264 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19265 if (SWIG_arg_fail(3)) SWIG_fail;
19266 }
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 {
19276 resultobj = SWIG_From_int((int)(result));
19277 }
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxDateTime::Month arg1 ;
19287 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19288 wxString result;
19289 PyObject * obj0 = 0 ;
19290 PyObject * obj1 = 0 ;
19291 char *kwnames[] = {
19292 (char *) "month",(char *) "flags", NULL
19293 };
19294
19295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19296 {
19297 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19298 if (SWIG_arg_fail(1)) SWIG_fail;
19299 }
19300 if (obj1) {
19301 {
19302 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19303 if (SWIG_arg_fail(2)) SWIG_fail;
19304 }
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 {
19314 #if wxUSE_UNICODE
19315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19316 #else
19317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19318 #endif
19319 }
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19327 PyObject *resultobj;
19328 wxDateTime::WeekDay arg1 ;
19329 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19330 wxString result;
19331 PyObject * obj0 = 0 ;
19332 PyObject * obj1 = 0 ;
19333 char *kwnames[] = {
19334 (char *) "weekday",(char *) "flags", NULL
19335 };
19336
19337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19338 {
19339 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19340 if (SWIG_arg_fail(1)) SWIG_fail;
19341 }
19342 if (obj1) {
19343 {
19344 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19345 if (SWIG_arg_fail(2)) SWIG_fail;
19346 }
19347 }
19348 {
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19351
19352 wxPyEndAllowThreads(__tstate);
19353 if (PyErr_Occurred()) SWIG_fail;
19354 }
19355 {
19356 #if wxUSE_UNICODE
19357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19358 #else
19359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19360 #endif
19361 }
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19369 PyObject *resultobj;
19370 PyObject *result;
19371 char *kwnames[] = {
19372 NULL
19373 };
19374
19375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (PyObject *)DateTime_GetAmPmStrings();
19379
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = result;
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19391 PyObject *resultobj;
19392 int arg1 = (int) wxDateTime::Inv_Year ;
19393 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19394 bool result;
19395 PyObject * obj0 = 0 ;
19396 PyObject * obj1 = 0 ;
19397 char *kwnames[] = {
19398 (char *) "year",(char *) "country", NULL
19399 };
19400
19401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19402 if (obj0) {
19403 {
19404 arg1 = (int)(SWIG_As_int(obj0));
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 }
19407 }
19408 if (obj1) {
19409 {
19410 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19411 if (SWIG_arg_fail(2)) SWIG_fail;
19412 }
19413 }
19414 {
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19417
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 {
19422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19423 }
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 int arg1 = (int) wxDateTime::Inv_Year ;
19433 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19434 wxDateTime result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "year",(char *) "country", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19442 if (obj0) {
19443 {
19444 arg1 = (int)(SWIG_As_int(obj0));
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 }
19447 }
19448 if (obj1) {
19449 {
19450 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19451 if (SWIG_arg_fail(2)) SWIG_fail;
19452 }
19453 }
19454 {
19455 PyThreadState* __tstate = wxPyBeginAllowThreads();
19456 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19457
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 {
19462 wxDateTime * resultptr;
19463 resultptr = new wxDateTime((wxDateTime &)(result));
19464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19465 }
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj;
19474 int arg1 = (int) wxDateTime::Inv_Year ;
19475 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19476 wxDateTime result;
19477 PyObject * obj0 = 0 ;
19478 PyObject * obj1 = 0 ;
19479 char *kwnames[] = {
19480 (char *) "year",(char *) "country", NULL
19481 };
19482
19483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19484 if (obj0) {
19485 {
19486 arg1 = (int)(SWIG_As_int(obj0));
19487 if (SWIG_arg_fail(1)) SWIG_fail;
19488 }
19489 }
19490 if (obj1) {
19491 {
19492 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19493 if (SWIG_arg_fail(2)) SWIG_fail;
19494 }
19495 }
19496 {
19497 PyThreadState* __tstate = wxPyBeginAllowThreads();
19498 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19499
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 {
19504 wxDateTime * resultptr;
19505 resultptr = new wxDateTime((wxDateTime &)(result));
19506 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19507 }
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19515 PyObject *resultobj;
19516 wxDateTime result;
19517 char *kwnames[] = {
19518 NULL
19519 };
19520
19521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19522 {
19523 PyThreadState* __tstate = wxPyBeginAllowThreads();
19524 result = wxDateTime::Now();
19525
19526 wxPyEndAllowThreads(__tstate);
19527 if (PyErr_Occurred()) SWIG_fail;
19528 }
19529 {
19530 wxDateTime * resultptr;
19531 resultptr = new wxDateTime((wxDateTime &)(result));
19532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19533 }
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19541 PyObject *resultobj;
19542 wxDateTime result;
19543 char *kwnames[] = {
19544 NULL
19545 };
19546
19547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19548 {
19549 PyThreadState* __tstate = wxPyBeginAllowThreads();
19550 result = wxDateTime::UNow();
19551
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 {
19556 wxDateTime * resultptr;
19557 resultptr = new wxDateTime((wxDateTime &)(result));
19558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19559 }
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj;
19568 wxDateTime result;
19569 char *kwnames[] = {
19570 NULL
19571 };
19572
19573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 result = wxDateTime::Today();
19577
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 {
19582 wxDateTime * resultptr;
19583 resultptr = new wxDateTime((wxDateTime &)(result));
19584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19585 }
19586 return resultobj;
19587 fail:
19588 return NULL;
19589 }
19590
19591
19592 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19593 PyObject *resultobj;
19594 wxDateTime *result;
19595 char *kwnames[] = {
19596 NULL
19597 };
19598
19599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxDateTime *)new wxDateTime();
19603
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj;
19616 time_t arg1 ;
19617 wxDateTime *result;
19618 PyObject * obj0 = 0 ;
19619 char *kwnames[] = {
19620 (char *) "timet", NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19624 {
19625 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19626 if (SWIG_arg_fail(1)) SWIG_fail;
19627 }
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = (wxDateTime *)new wxDateTime(arg1);
19631
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj;
19644 double arg1 ;
19645 wxDateTime *result;
19646 PyObject * obj0 = 0 ;
19647 char *kwnames[] = {
19648 (char *) "jdn", NULL
19649 };
19650
19651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19652 {
19653 arg1 = (double)(SWIG_As_double(obj0));
19654 if (SWIG_arg_fail(1)) SWIG_fail;
19655 }
19656 {
19657 PyThreadState* __tstate = wxPyBeginAllowThreads();
19658 result = (wxDateTime *)new wxDateTime(arg1);
19659
19660 wxPyEndAllowThreads(__tstate);
19661 if (PyErr_Occurred()) SWIG_fail;
19662 }
19663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19664 return resultobj;
19665 fail:
19666 return NULL;
19667 }
19668
19669
19670 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19671 PyObject *resultobj;
19672 int arg1 ;
19673 int arg2 = (int) 0 ;
19674 int arg3 = (int) 0 ;
19675 int arg4 = (int) 0 ;
19676 wxDateTime *result;
19677 PyObject * obj0 = 0 ;
19678 PyObject * obj1 = 0 ;
19679 PyObject * obj2 = 0 ;
19680 PyObject * obj3 = 0 ;
19681 char *kwnames[] = {
19682 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19683 };
19684
19685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19686 {
19687 arg1 = (int)(SWIG_As_int(obj0));
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 }
19690 if (obj1) {
19691 {
19692 arg2 = (int)(SWIG_As_int(obj1));
19693 if (SWIG_arg_fail(2)) SWIG_fail;
19694 }
19695 }
19696 if (obj2) {
19697 {
19698 arg3 = (int)(SWIG_As_int(obj2));
19699 if (SWIG_arg_fail(3)) SWIG_fail;
19700 }
19701 }
19702 if (obj3) {
19703 {
19704 arg4 = (int)(SWIG_As_int(obj3));
19705 if (SWIG_arg_fail(4)) SWIG_fail;
19706 }
19707 }
19708 {
19709 PyThreadState* __tstate = wxPyBeginAllowThreads();
19710 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19711
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19723 PyObject *resultobj;
19724 int arg1 ;
19725 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19726 int arg3 = (int) wxDateTime::Inv_Year ;
19727 int arg4 = (int) 0 ;
19728 int arg5 = (int) 0 ;
19729 int arg6 = (int) 0 ;
19730 int arg7 = (int) 0 ;
19731 wxDateTime *result;
19732 PyObject * obj0 = 0 ;
19733 PyObject * obj1 = 0 ;
19734 PyObject * obj2 = 0 ;
19735 PyObject * obj3 = 0 ;
19736 PyObject * obj4 = 0 ;
19737 PyObject * obj5 = 0 ;
19738 PyObject * obj6 = 0 ;
19739 char *kwnames[] = {
19740 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19741 };
19742
19743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19744 {
19745 arg1 = (int)(SWIG_As_int(obj0));
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 }
19748 if (obj1) {
19749 {
19750 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19751 if (SWIG_arg_fail(2)) SWIG_fail;
19752 }
19753 }
19754 if (obj2) {
19755 {
19756 arg3 = (int)(SWIG_As_int(obj2));
19757 if (SWIG_arg_fail(3)) SWIG_fail;
19758 }
19759 }
19760 if (obj3) {
19761 {
19762 arg4 = (int)(SWIG_As_int(obj3));
19763 if (SWIG_arg_fail(4)) SWIG_fail;
19764 }
19765 }
19766 if (obj4) {
19767 {
19768 arg5 = (int)(SWIG_As_int(obj4));
19769 if (SWIG_arg_fail(5)) SWIG_fail;
19770 }
19771 }
19772 if (obj5) {
19773 {
19774 arg6 = (int)(SWIG_As_int(obj5));
19775 if (SWIG_arg_fail(6)) SWIG_fail;
19776 }
19777 }
19778 if (obj6) {
19779 {
19780 arg7 = (int)(SWIG_As_int(obj6));
19781 if (SWIG_arg_fail(7)) SWIG_fail;
19782 }
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19787
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj;
19800 wxDateTime *arg1 = (wxDateTime *) 0 ;
19801 PyObject * obj0 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 delete arg1;
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 Py_INCREF(Py_None); resultobj = Py_None;
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj;
19825 wxDateTime *arg1 = (wxDateTime *) 0 ;
19826 wxDateTime *result;
19827 PyObject * obj0 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "self", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19834 if (SWIG_arg_fail(1)) SWIG_fail;
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 {
19838 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19839 result = (wxDateTime *) &_result_ref;
19840 }
19841
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19846 return resultobj;
19847 fail:
19848 return NULL;
19849 }
19850
19851
19852 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19853 PyObject *resultobj;
19854 wxDateTime *arg1 = (wxDateTime *) 0 ;
19855 time_t arg2 ;
19856 wxDateTime *result;
19857 PyObject * obj0 = 0 ;
19858 PyObject * obj1 = 0 ;
19859 char *kwnames[] = {
19860 (char *) "self",(char *) "timet", NULL
19861 };
19862
19863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19865 if (SWIG_arg_fail(1)) SWIG_fail;
19866 {
19867 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19868 if (SWIG_arg_fail(2)) SWIG_fail;
19869 }
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 {
19873 wxDateTime &_result_ref = (arg1)->Set(arg2);
19874 result = (wxDateTime *) &_result_ref;
19875 }
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxDateTime *arg1 = (wxDateTime *) 0 ;
19890 double arg2 ;
19891 wxDateTime *result;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self",(char *) "jdn", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 {
19902 arg2 = (double)(SWIG_As_double(obj1));
19903 if (SWIG_arg_fail(2)) SWIG_fail;
19904 }
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 {
19908 wxDateTime &_result_ref = (arg1)->Set(arg2);
19909 result = (wxDateTime *) &_result_ref;
19910 }
19911
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19916 return resultobj;
19917 fail:
19918 return NULL;
19919 }
19920
19921
19922 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19923 PyObject *resultobj;
19924 wxDateTime *arg1 = (wxDateTime *) 0 ;
19925 int arg2 ;
19926 int arg3 = (int) 0 ;
19927 int arg4 = (int) 0 ;
19928 int arg5 = (int) 0 ;
19929 wxDateTime *result;
19930 PyObject * obj0 = 0 ;
19931 PyObject * obj1 = 0 ;
19932 PyObject * obj2 = 0 ;
19933 PyObject * obj3 = 0 ;
19934 PyObject * obj4 = 0 ;
19935 char *kwnames[] = {
19936 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19937 };
19938
19939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19941 if (SWIG_arg_fail(1)) SWIG_fail;
19942 {
19943 arg2 = (int)(SWIG_As_int(obj1));
19944 if (SWIG_arg_fail(2)) SWIG_fail;
19945 }
19946 if (obj2) {
19947 {
19948 arg3 = (int)(SWIG_As_int(obj2));
19949 if (SWIG_arg_fail(3)) SWIG_fail;
19950 }
19951 }
19952 if (obj3) {
19953 {
19954 arg4 = (int)(SWIG_As_int(obj3));
19955 if (SWIG_arg_fail(4)) SWIG_fail;
19956 }
19957 }
19958 if (obj4) {
19959 {
19960 arg5 = (int)(SWIG_As_int(obj4));
19961 if (SWIG_arg_fail(5)) SWIG_fail;
19962 }
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 {
19967 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19968 result = (wxDateTime *) &_result_ref;
19969 }
19970
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj;
19983 wxDateTime *arg1 = (wxDateTime *) 0 ;
19984 int arg2 ;
19985 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19986 int arg4 = (int) wxDateTime::Inv_Year ;
19987 int arg5 = (int) 0 ;
19988 int arg6 = (int) 0 ;
19989 int arg7 = (int) 0 ;
19990 int arg8 = (int) 0 ;
19991 wxDateTime *result;
19992 PyObject * obj0 = 0 ;
19993 PyObject * obj1 = 0 ;
19994 PyObject * obj2 = 0 ;
19995 PyObject * obj3 = 0 ;
19996 PyObject * obj4 = 0 ;
19997 PyObject * obj5 = 0 ;
19998 PyObject * obj6 = 0 ;
19999 PyObject * obj7 = 0 ;
20000 char *kwnames[] = {
20001 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20002 };
20003
20004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20006 if (SWIG_arg_fail(1)) SWIG_fail;
20007 {
20008 arg2 = (int)(SWIG_As_int(obj1));
20009 if (SWIG_arg_fail(2)) SWIG_fail;
20010 }
20011 if (obj2) {
20012 {
20013 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20014 if (SWIG_arg_fail(3)) SWIG_fail;
20015 }
20016 }
20017 if (obj3) {
20018 {
20019 arg4 = (int)(SWIG_As_int(obj3));
20020 if (SWIG_arg_fail(4)) SWIG_fail;
20021 }
20022 }
20023 if (obj4) {
20024 {
20025 arg5 = (int)(SWIG_As_int(obj4));
20026 if (SWIG_arg_fail(5)) SWIG_fail;
20027 }
20028 }
20029 if (obj5) {
20030 {
20031 arg6 = (int)(SWIG_As_int(obj5));
20032 if (SWIG_arg_fail(6)) SWIG_fail;
20033 }
20034 }
20035 if (obj6) {
20036 {
20037 arg7 = (int)(SWIG_As_int(obj6));
20038 if (SWIG_arg_fail(7)) SWIG_fail;
20039 }
20040 }
20041 if (obj7) {
20042 {
20043 arg8 = (int)(SWIG_As_int(obj7));
20044 if (SWIG_arg_fail(8)) SWIG_fail;
20045 }
20046 }
20047 {
20048 PyThreadState* __tstate = wxPyBeginAllowThreads();
20049 {
20050 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20051 result = (wxDateTime *) &_result_ref;
20052 }
20053
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj;
20066 wxDateTime *arg1 = (wxDateTime *) 0 ;
20067 wxDateTime *result;
20068 PyObject * obj0 = 0 ;
20069 char *kwnames[] = {
20070 (char *) "self", NULL
20071 };
20072
20073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20075 if (SWIG_arg_fail(1)) SWIG_fail;
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 {
20079 wxDateTime &_result_ref = (arg1)->ResetTime();
20080 result = (wxDateTime *) &_result_ref;
20081 }
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj;
20095 wxDateTime *arg1 = (wxDateTime *) 0 ;
20096 int arg2 ;
20097 wxDateTime *result;
20098 PyObject * obj0 = 0 ;
20099 PyObject * obj1 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "self",(char *) "year", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20106 if (SWIG_arg_fail(1)) SWIG_fail;
20107 {
20108 arg2 = (int)(SWIG_As_int(obj1));
20109 if (SWIG_arg_fail(2)) SWIG_fail;
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 {
20114 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20115 result = (wxDateTime *) &_result_ref;
20116 }
20117
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20122 return resultobj;
20123 fail:
20124 return NULL;
20125 }
20126
20127
20128 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 wxDateTime *arg1 = (wxDateTime *) 0 ;
20131 wxDateTime::Month arg2 ;
20132 wxDateTime *result;
20133 PyObject * obj0 = 0 ;
20134 PyObject * obj1 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "self",(char *) "month", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20141 if (SWIG_arg_fail(1)) SWIG_fail;
20142 {
20143 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20144 if (SWIG_arg_fail(2)) SWIG_fail;
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 {
20149 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20150 result = (wxDateTime *) &_result_ref;
20151 }
20152
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj;
20165 wxDateTime *arg1 = (wxDateTime *) 0 ;
20166 int arg2 ;
20167 wxDateTime *result;
20168 PyObject * obj0 = 0 ;
20169 PyObject * obj1 = 0 ;
20170 char *kwnames[] = {
20171 (char *) "self",(char *) "day", NULL
20172 };
20173
20174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20176 if (SWIG_arg_fail(1)) SWIG_fail;
20177 {
20178 arg2 = (int)(SWIG_As_int(obj1));
20179 if (SWIG_arg_fail(2)) SWIG_fail;
20180 }
20181 {
20182 PyThreadState* __tstate = wxPyBeginAllowThreads();
20183 {
20184 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20185 result = (wxDateTime *) &_result_ref;
20186 }
20187
20188 wxPyEndAllowThreads(__tstate);
20189 if (PyErr_Occurred()) SWIG_fail;
20190 }
20191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20192 return resultobj;
20193 fail:
20194 return NULL;
20195 }
20196
20197
20198 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20199 PyObject *resultobj;
20200 wxDateTime *arg1 = (wxDateTime *) 0 ;
20201 int arg2 ;
20202 wxDateTime *result;
20203 PyObject * obj0 = 0 ;
20204 PyObject * obj1 = 0 ;
20205 char *kwnames[] = {
20206 (char *) "self",(char *) "hour", NULL
20207 };
20208
20209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20211 if (SWIG_arg_fail(1)) SWIG_fail;
20212 {
20213 arg2 = (int)(SWIG_As_int(obj1));
20214 if (SWIG_arg_fail(2)) SWIG_fail;
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 {
20219 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20220 result = (wxDateTime *) &_result_ref;
20221 }
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20234 PyObject *resultobj;
20235 wxDateTime *arg1 = (wxDateTime *) 0 ;
20236 int arg2 ;
20237 wxDateTime *result;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "self",(char *) "minute", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(1)) SWIG_fail;
20247 {
20248 arg2 = (int)(SWIG_As_int(obj1));
20249 if (SWIG_arg_fail(2)) SWIG_fail;
20250 }
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 {
20254 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20255 result = (wxDateTime *) &_result_ref;
20256 }
20257
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj;
20270 wxDateTime *arg1 = (wxDateTime *) 0 ;
20271 int arg2 ;
20272 wxDateTime *result;
20273 PyObject * obj0 = 0 ;
20274 PyObject * obj1 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self",(char *) "second", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 arg2 = (int)(SWIG_As_int(obj1));
20284 if (SWIG_arg_fail(2)) SWIG_fail;
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 {
20289 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20290 result = (wxDateTime *) &_result_ref;
20291 }
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj;
20305 wxDateTime *arg1 = (wxDateTime *) 0 ;
20306 int arg2 ;
20307 wxDateTime *result;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "millisecond", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = (int)(SWIG_As_int(obj1));
20319 if (SWIG_arg_fail(2)) SWIG_fail;
20320 }
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 {
20324 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20325 result = (wxDateTime *) &_result_ref;
20326 }
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxDateTime *arg1 = (wxDateTime *) 0 ;
20341 wxDateTime::WeekDay arg2 ;
20342 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20343 wxDateTime *result;
20344 PyObject * obj0 = 0 ;
20345 PyObject * obj1 = 0 ;
20346 PyObject * obj2 = 0 ;
20347 char *kwnames[] = {
20348 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20349 };
20350
20351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20353 if (SWIG_arg_fail(1)) SWIG_fail;
20354 {
20355 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20356 if (SWIG_arg_fail(2)) SWIG_fail;
20357 }
20358 if (obj2) {
20359 {
20360 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20361 if (SWIG_arg_fail(3)) SWIG_fail;
20362 }
20363 }
20364 {
20365 PyThreadState* __tstate = wxPyBeginAllowThreads();
20366 {
20367 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20368 result = (wxDateTime *) &_result_ref;
20369 }
20370
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20382 PyObject *resultobj;
20383 wxDateTime *arg1 = (wxDateTime *) 0 ;
20384 wxDateTime::WeekDay arg2 ;
20385 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20386 wxDateTime result;
20387 PyObject * obj0 = 0 ;
20388 PyObject * obj1 = 0 ;
20389 PyObject * obj2 = 0 ;
20390 char *kwnames[] = {
20391 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20392 };
20393
20394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20396 if (SWIG_arg_fail(1)) SWIG_fail;
20397 {
20398 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20399 if (SWIG_arg_fail(2)) SWIG_fail;
20400 }
20401 if (obj2) {
20402 {
20403 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20404 if (SWIG_arg_fail(3)) SWIG_fail;
20405 }
20406 }
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20410
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 wxDateTime * resultptr;
20416 resultptr = new wxDateTime((wxDateTime &)(result));
20417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 wxDateTime *arg1 = (wxDateTime *) 0 ;
20428 wxDateTime::WeekDay arg2 ;
20429 wxDateTime *result;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self",(char *) "weekday", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20441 if (SWIG_arg_fail(2)) SWIG_fail;
20442 }
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 {
20446 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20447 result = (wxDateTime *) &_result_ref;
20448 }
20449
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20461 PyObject *resultobj;
20462 wxDateTime *arg1 = (wxDateTime *) 0 ;
20463 wxDateTime::WeekDay arg2 ;
20464 wxDateTime result;
20465 PyObject * obj0 = 0 ;
20466 PyObject * obj1 = 0 ;
20467 char *kwnames[] = {
20468 (char *) "self",(char *) "weekday", NULL
20469 };
20470
20471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20473 if (SWIG_arg_fail(1)) SWIG_fail;
20474 {
20475 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20476 if (SWIG_arg_fail(2)) SWIG_fail;
20477 }
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 wxDateTime * resultptr;
20487 resultptr = new wxDateTime((wxDateTime &)(result));
20488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20489 }
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj;
20498 wxDateTime *arg1 = (wxDateTime *) 0 ;
20499 wxDateTime::WeekDay arg2 ;
20500 wxDateTime *result;
20501 PyObject * obj0 = 0 ;
20502 PyObject * obj1 = 0 ;
20503 char *kwnames[] = {
20504 (char *) "self",(char *) "weekday", NULL
20505 };
20506
20507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 {
20511 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20512 if (SWIG_arg_fail(2)) SWIG_fail;
20513 }
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 {
20517 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20518 result = (wxDateTime *) &_result_ref;
20519 }
20520
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxDateTime *arg1 = (wxDateTime *) 0 ;
20534 wxDateTime::WeekDay arg2 ;
20535 wxDateTime result;
20536 PyObject * obj0 = 0 ;
20537 PyObject * obj1 = 0 ;
20538 char *kwnames[] = {
20539 (char *) "self",(char *) "weekday", NULL
20540 };
20541
20542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 {
20546 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20547 if (SWIG_arg_fail(2)) SWIG_fail;
20548 }
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20552
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 wxDateTime * resultptr;
20558 resultptr = new wxDateTime((wxDateTime &)(result));
20559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 wxDateTime *arg1 = (wxDateTime *) 0 ;
20570 wxDateTime::WeekDay arg2 ;
20571 int arg3 = (int) 1 ;
20572 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20573 int arg5 = (int) wxDateTime::Inv_Year ;
20574 bool result;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 PyObject * obj2 = 0 ;
20578 PyObject * obj3 = 0 ;
20579 PyObject * obj4 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20586 if (SWIG_arg_fail(1)) SWIG_fail;
20587 {
20588 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20589 if (SWIG_arg_fail(2)) SWIG_fail;
20590 }
20591 if (obj2) {
20592 {
20593 arg3 = (int)(SWIG_As_int(obj2));
20594 if (SWIG_arg_fail(3)) SWIG_fail;
20595 }
20596 }
20597 if (obj3) {
20598 {
20599 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20600 if (SWIG_arg_fail(4)) SWIG_fail;
20601 }
20602 }
20603 if (obj4) {
20604 {
20605 arg5 = (int)(SWIG_As_int(obj4));
20606 if (SWIG_arg_fail(5)) SWIG_fail;
20607 }
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20626 PyObject *resultobj;
20627 wxDateTime *arg1 = (wxDateTime *) 0 ;
20628 wxDateTime::WeekDay arg2 ;
20629 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20630 int arg4 = (int) wxDateTime::Inv_Year ;
20631 bool result;
20632 PyObject * obj0 = 0 ;
20633 PyObject * obj1 = 0 ;
20634 PyObject * obj2 = 0 ;
20635 PyObject * obj3 = 0 ;
20636 char *kwnames[] = {
20637 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20638 };
20639
20640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20642 if (SWIG_arg_fail(1)) SWIG_fail;
20643 {
20644 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20645 if (SWIG_arg_fail(2)) SWIG_fail;
20646 }
20647 if (obj2) {
20648 {
20649 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20650 if (SWIG_arg_fail(3)) SWIG_fail;
20651 }
20652 }
20653 if (obj3) {
20654 {
20655 arg4 = (int)(SWIG_As_int(obj3));
20656 if (SWIG_arg_fail(4)) SWIG_fail;
20657 }
20658 }
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20662
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 {
20667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20668 }
20669 return resultobj;
20670 fail:
20671 return NULL;
20672 }
20673
20674
20675 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20676 PyObject *resultobj;
20677 wxDateTime *arg1 = (wxDateTime *) 0 ;
20678 wxDateTime::WeekDay arg2 ;
20679 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20680 int arg4 = (int) wxDateTime::Inv_Year ;
20681 wxDateTime result;
20682 PyObject * obj0 = 0 ;
20683 PyObject * obj1 = 0 ;
20684 PyObject * obj2 = 0 ;
20685 PyObject * obj3 = 0 ;
20686 char *kwnames[] = {
20687 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20688 };
20689
20690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20692 if (SWIG_arg_fail(1)) SWIG_fail;
20693 {
20694 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20695 if (SWIG_arg_fail(2)) SWIG_fail;
20696 }
20697 if (obj2) {
20698 {
20699 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20700 if (SWIG_arg_fail(3)) SWIG_fail;
20701 }
20702 }
20703 if (obj3) {
20704 {
20705 arg4 = (int)(SWIG_As_int(obj3));
20706 if (SWIG_arg_fail(4)) SWIG_fail;
20707 }
20708 }
20709 {
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20712
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 {
20717 wxDateTime * resultptr;
20718 resultptr = new wxDateTime((wxDateTime &)(result));
20719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20720 }
20721 return resultobj;
20722 fail:
20723 return NULL;
20724 }
20725
20726
20727 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20728 PyObject *resultobj;
20729 wxDateTime *arg1 = (wxDateTime *) 0 ;
20730 int arg2 ;
20731 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20732 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20733 bool result;
20734 PyObject * obj0 = 0 ;
20735 PyObject * obj1 = 0 ;
20736 PyObject * obj2 = 0 ;
20737 PyObject * obj3 = 0 ;
20738 char *kwnames[] = {
20739 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20740 };
20741
20742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20744 if (SWIG_arg_fail(1)) SWIG_fail;
20745 {
20746 arg2 = (int)(SWIG_As_int(obj1));
20747 if (SWIG_arg_fail(2)) SWIG_fail;
20748 }
20749 if (obj2) {
20750 {
20751 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20752 if (SWIG_arg_fail(3)) SWIG_fail;
20753 }
20754 }
20755 if (obj3) {
20756 {
20757 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20758 if (SWIG_arg_fail(4)) SWIG_fail;
20759 }
20760 }
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20764
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 {
20769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20770 }
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20778 PyObject *resultobj;
20779 wxDateTime *arg1 = (wxDateTime *) 0 ;
20780 int arg2 ;
20781 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20782 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20783 wxDateTime result;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 PyObject * obj2 = 0 ;
20787 PyObject * obj3 = 0 ;
20788 char *kwnames[] = {
20789 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20790 };
20791
20792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 {
20796 arg2 = (int)(SWIG_As_int(obj1));
20797 if (SWIG_arg_fail(2)) SWIG_fail;
20798 }
20799 if (obj2) {
20800 {
20801 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20802 if (SWIG_arg_fail(3)) SWIG_fail;
20803 }
20804 }
20805 if (obj3) {
20806 {
20807 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20808 if (SWIG_arg_fail(4)) SWIG_fail;
20809 }
20810 }
20811 {
20812 PyThreadState* __tstate = wxPyBeginAllowThreads();
20813 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20814
20815 wxPyEndAllowThreads(__tstate);
20816 if (PyErr_Occurred()) SWIG_fail;
20817 }
20818 {
20819 wxDateTime * resultptr;
20820 resultptr = new wxDateTime((wxDateTime &)(result));
20821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20822 }
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20830 PyObject *resultobj;
20831 int arg1 ;
20832 int arg2 ;
20833 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20834 wxDateTime result;
20835 PyObject * obj0 = 0 ;
20836 PyObject * obj1 = 0 ;
20837 PyObject * obj2 = 0 ;
20838 char *kwnames[] = {
20839 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20840 };
20841
20842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20843 {
20844 arg1 = (int)(SWIG_As_int(obj0));
20845 if (SWIG_arg_fail(1)) SWIG_fail;
20846 }
20847 {
20848 arg2 = (int)(SWIG_As_int(obj1));
20849 if (SWIG_arg_fail(2)) SWIG_fail;
20850 }
20851 if (obj2) {
20852 {
20853 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20854 if (SWIG_arg_fail(3)) SWIG_fail;
20855 }
20856 }
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 wxDateTime * resultptr;
20866 resultptr = new wxDateTime((wxDateTime &)(result));
20867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20868 }
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 wxDateTime *arg1 = (wxDateTime *) 0 ;
20878 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20879 int arg3 = (int) wxDateTime::Inv_Year ;
20880 wxDateTime *result;
20881 PyObject * obj0 = 0 ;
20882 PyObject * obj1 = 0 ;
20883 PyObject * obj2 = 0 ;
20884 char *kwnames[] = {
20885 (char *) "self",(char *) "month",(char *) "year", NULL
20886 };
20887
20888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20890 if (SWIG_arg_fail(1)) SWIG_fail;
20891 if (obj1) {
20892 {
20893 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20894 if (SWIG_arg_fail(2)) SWIG_fail;
20895 }
20896 }
20897 if (obj2) {
20898 {
20899 arg3 = (int)(SWIG_As_int(obj2));
20900 if (SWIG_arg_fail(3)) SWIG_fail;
20901 }
20902 }
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 {
20906 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20907 result = (wxDateTime *) &_result_ref;
20908 }
20909
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj;
20922 wxDateTime *arg1 = (wxDateTime *) 0 ;
20923 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20924 int arg3 = (int) wxDateTime::Inv_Year ;
20925 wxDateTime result;
20926 PyObject * obj0 = 0 ;
20927 PyObject * obj1 = 0 ;
20928 PyObject * obj2 = 0 ;
20929 char *kwnames[] = {
20930 (char *) "self",(char *) "month",(char *) "year", NULL
20931 };
20932
20933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20935 if (SWIG_arg_fail(1)) SWIG_fail;
20936 if (obj1) {
20937 {
20938 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20939 if (SWIG_arg_fail(2)) SWIG_fail;
20940 }
20941 }
20942 if (obj2) {
20943 {
20944 arg3 = (int)(SWIG_As_int(obj2));
20945 if (SWIG_arg_fail(3)) SWIG_fail;
20946 }
20947 }
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 wxDateTime * resultptr;
20957 resultptr = new wxDateTime((wxDateTime &)(result));
20958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj;
20968 wxDateTime *arg1 = (wxDateTime *) 0 ;
20969 int arg2 ;
20970 wxDateTime *result;
20971 PyObject * obj0 = 0 ;
20972 PyObject * obj1 = 0 ;
20973 char *kwnames[] = {
20974 (char *) "self",(char *) "yday", NULL
20975 };
20976
20977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 {
20981 arg2 = (int)(SWIG_As_int(obj1));
20982 if (SWIG_arg_fail(2)) SWIG_fail;
20983 }
20984 {
20985 PyThreadState* __tstate = wxPyBeginAllowThreads();
20986 {
20987 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20988 result = (wxDateTime *) &_result_ref;
20989 }
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxDateTime *arg1 = (wxDateTime *) 0 ;
21004 int arg2 ;
21005 wxDateTime result;
21006 PyObject * obj0 = 0 ;
21007 PyObject * obj1 = 0 ;
21008 char *kwnames[] = {
21009 (char *) "self",(char *) "yday", NULL
21010 };
21011
21012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21014 if (SWIG_arg_fail(1)) SWIG_fail;
21015 {
21016 arg2 = (int)(SWIG_As_int(obj1));
21017 if (SWIG_arg_fail(2)) SWIG_fail;
21018 }
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 result = (arg1)->GetYearDay(arg2);
21022
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 {
21027 wxDateTime * resultptr;
21028 resultptr = new wxDateTime((wxDateTime &)(result));
21029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21030 }
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj;
21039 wxDateTime *arg1 = (wxDateTime *) 0 ;
21040 double result;
21041 PyObject * obj0 = 0 ;
21042 char *kwnames[] = {
21043 (char *) "self", NULL
21044 };
21045
21046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21048 if (SWIG_arg_fail(1)) SWIG_fail;
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (double)(arg1)->GetJulianDayNumber();
21052
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 {
21057 resultobj = SWIG_From_double((double)(result));
21058 }
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21066 PyObject *resultobj;
21067 wxDateTime *arg1 = (wxDateTime *) 0 ;
21068 double result;
21069 PyObject * obj0 = 0 ;
21070 char *kwnames[] = {
21071 (char *) "self", NULL
21072 };
21073
21074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21076 if (SWIG_arg_fail(1)) SWIG_fail;
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (double)(arg1)->GetJDN();
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 {
21085 resultobj = SWIG_From_double((double)(result));
21086 }
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj;
21095 wxDateTime *arg1 = (wxDateTime *) 0 ;
21096 double result;
21097 PyObject * obj0 = 0 ;
21098 char *kwnames[] = {
21099 (char *) "self", NULL
21100 };
21101
21102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21104 if (SWIG_arg_fail(1)) SWIG_fail;
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21108
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 {
21113 resultobj = SWIG_From_double((double)(result));
21114 }
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21122 PyObject *resultobj;
21123 wxDateTime *arg1 = (wxDateTime *) 0 ;
21124 double result;
21125 PyObject * obj0 = 0 ;
21126 char *kwnames[] = {
21127 (char *) "self", NULL
21128 };
21129
21130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21132 if (SWIG_arg_fail(1)) SWIG_fail;
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (double)(arg1)->GetMJD();
21136
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 {
21141 resultobj = SWIG_From_double((double)(result));
21142 }
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21150 PyObject *resultobj;
21151 wxDateTime *arg1 = (wxDateTime *) 0 ;
21152 double result;
21153 PyObject * obj0 = 0 ;
21154 char *kwnames[] = {
21155 (char *) "self", NULL
21156 };
21157
21158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21160 if (SWIG_arg_fail(1)) SWIG_fail;
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (double)(arg1)->GetRataDie();
21164
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 {
21169 resultobj = SWIG_From_double((double)(result));
21170 }
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21178 PyObject *resultobj;
21179 wxDateTime *arg1 = (wxDateTime *) 0 ;
21180 wxDateTime::TimeZone *arg2 = 0 ;
21181 bool arg3 = (bool) false ;
21182 wxDateTime result;
21183 bool temp2 = false ;
21184 PyObject * obj0 = 0 ;
21185 PyObject * obj1 = 0 ;
21186 PyObject * obj2 = 0 ;
21187 char *kwnames[] = {
21188 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21189 };
21190
21191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21193 if (SWIG_arg_fail(1)) SWIG_fail;
21194 {
21195 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21196 temp2 = true;
21197 }
21198 if (obj2) {
21199 {
21200 arg3 = (bool)(SWIG_As_bool(obj2));
21201 if (SWIG_arg_fail(3)) SWIG_fail;
21202 }
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21207
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 {
21212 wxDateTime * resultptr;
21213 resultptr = new wxDateTime((wxDateTime &)(result));
21214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21215 }
21216 {
21217 if (temp2) delete arg2;
21218 }
21219 return resultobj;
21220 fail:
21221 {
21222 if (temp2) delete arg2;
21223 }
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxDateTime *arg1 = (wxDateTime *) 0 ;
21231 wxDateTime::TimeZone *arg2 = 0 ;
21232 bool arg3 = (bool) false ;
21233 wxDateTime *result;
21234 bool temp2 = false ;
21235 PyObject * obj0 = 0 ;
21236 PyObject * obj1 = 0 ;
21237 PyObject * obj2 = 0 ;
21238 char *kwnames[] = {
21239 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21240 };
21241
21242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21244 if (SWIG_arg_fail(1)) SWIG_fail;
21245 {
21246 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21247 temp2 = true;
21248 }
21249 if (obj2) {
21250 {
21251 arg3 = (bool)(SWIG_As_bool(obj2));
21252 if (SWIG_arg_fail(3)) SWIG_fail;
21253 }
21254 }
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 {
21258 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21259 result = (wxDateTime *) &_result_ref;
21260 }
21261
21262 wxPyEndAllowThreads(__tstate);
21263 if (PyErr_Occurred()) SWIG_fail;
21264 }
21265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21266 {
21267 if (temp2) delete arg2;
21268 }
21269 return resultobj;
21270 fail:
21271 {
21272 if (temp2) delete arg2;
21273 }
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj;
21280 wxDateTime *arg1 = (wxDateTime *) 0 ;
21281 bool arg2 = (bool) false ;
21282 wxDateTime result;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self",(char *) "noDST", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 if (obj1) {
21293 {
21294 arg2 = (bool)(SWIG_As_bool(obj1));
21295 if (SWIG_arg_fail(2)) SWIG_fail;
21296 }
21297 }
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 result = (arg1)->ToGMT(arg2);
21301
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 wxDateTime * resultptr;
21307 resultptr = new wxDateTime((wxDateTime &)(result));
21308 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21309 }
21310 return resultobj;
21311 fail:
21312 return NULL;
21313 }
21314
21315
21316 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21317 PyObject *resultobj;
21318 wxDateTime *arg1 = (wxDateTime *) 0 ;
21319 bool arg2 = (bool) false ;
21320 wxDateTime *result;
21321 PyObject * obj0 = 0 ;
21322 PyObject * obj1 = 0 ;
21323 char *kwnames[] = {
21324 (char *) "self",(char *) "noDST", NULL
21325 };
21326
21327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(1)) SWIG_fail;
21330 if (obj1) {
21331 {
21332 arg2 = (bool)(SWIG_As_bool(obj1));
21333 if (SWIG_arg_fail(2)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 {
21339 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21340 result = (wxDateTime *) &_result_ref;
21341 }
21342
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21347 return resultobj;
21348 fail:
21349 return NULL;
21350 }
21351
21352
21353 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxDateTime *arg1 = (wxDateTime *) 0 ;
21356 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21357 int result;
21358 PyObject * obj0 = 0 ;
21359 PyObject * obj1 = 0 ;
21360 char *kwnames[] = {
21361 (char *) "self",(char *) "country", NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21366 if (SWIG_arg_fail(1)) SWIG_fail;
21367 if (obj1) {
21368 {
21369 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21370 if (SWIG_arg_fail(2)) SWIG_fail;
21371 }
21372 }
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21376
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = SWIG_From_int((int)(result));
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxDateTime *arg1 = (wxDateTime *) 0 ;
21392 bool result;
21393 PyObject * obj0 = 0 ;
21394 char *kwnames[] = {
21395 (char *) "self", NULL
21396 };
21397
21398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21400 if (SWIG_arg_fail(1)) SWIG_fail;
21401 {
21402 PyThreadState* __tstate = wxPyBeginAllowThreads();
21403 result = (bool)((wxDateTime const *)arg1)->IsValid();
21404
21405 wxPyEndAllowThreads(__tstate);
21406 if (PyErr_Occurred()) SWIG_fail;
21407 }
21408 {
21409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21418 PyObject *resultobj;
21419 wxDateTime *arg1 = (wxDateTime *) 0 ;
21420 time_t result;
21421 PyObject * obj0 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 {
21437 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21438 }
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj;
21447 wxDateTime *arg1 = (wxDateTime *) 0 ;
21448 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21449 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21450 int result;
21451 bool temp2 = false ;
21452 PyObject * obj0 = 0 ;
21453 PyObject * obj1 = 0 ;
21454 char *kwnames[] = {
21455 (char *) "self",(char *) "tz", NULL
21456 };
21457
21458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21460 if (SWIG_arg_fail(1)) SWIG_fail;
21461 if (obj1) {
21462 {
21463 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21464 temp2 = true;
21465 }
21466 }
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21470
21471 wxPyEndAllowThreads(__tstate);
21472 if (PyErr_Occurred()) SWIG_fail;
21473 }
21474 {
21475 resultobj = SWIG_From_int((int)(result));
21476 }
21477 {
21478 if (temp2) delete arg2;
21479 }
21480 return resultobj;
21481 fail:
21482 {
21483 if (temp2) delete arg2;
21484 }
21485 return NULL;
21486 }
21487
21488
21489 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21490 PyObject *resultobj;
21491 wxDateTime *arg1 = (wxDateTime *) 0 ;
21492 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21493 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21494 wxDateTime::Month result;
21495 bool temp2 = false ;
21496 PyObject * obj0 = 0 ;
21497 PyObject * obj1 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "self",(char *) "tz", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(1)) SWIG_fail;
21505 if (obj1) {
21506 {
21507 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21508 temp2 = true;
21509 }
21510 }
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21514
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 resultobj = SWIG_From_int((result));
21519 {
21520 if (temp2) delete arg2;
21521 }
21522 return resultobj;
21523 fail:
21524 {
21525 if (temp2) delete arg2;
21526 }
21527 return NULL;
21528 }
21529
21530
21531 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21532 PyObject *resultobj;
21533 wxDateTime *arg1 = (wxDateTime *) 0 ;
21534 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21535 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21536 int result;
21537 bool temp2 = false ;
21538 PyObject * obj0 = 0 ;
21539 PyObject * obj1 = 0 ;
21540 char *kwnames[] = {
21541 (char *) "self",(char *) "tz", NULL
21542 };
21543
21544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21546 if (SWIG_arg_fail(1)) SWIG_fail;
21547 if (obj1) {
21548 {
21549 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21550 temp2 = true;
21551 }
21552 }
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21556
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 {
21561 resultobj = SWIG_From_int((int)(result));
21562 }
21563 {
21564 if (temp2) delete arg2;
21565 }
21566 return resultobj;
21567 fail:
21568 {
21569 if (temp2) delete arg2;
21570 }
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxDateTime *arg1 = (wxDateTime *) 0 ;
21578 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21579 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21580 wxDateTime::WeekDay result;
21581 bool temp2 = false ;
21582 PyObject * obj0 = 0 ;
21583 PyObject * obj1 = 0 ;
21584 char *kwnames[] = {
21585 (char *) "self",(char *) "tz", NULL
21586 };
21587
21588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21590 if (SWIG_arg_fail(1)) SWIG_fail;
21591 if (obj1) {
21592 {
21593 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21594 temp2 = true;
21595 }
21596 }
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 resultobj = SWIG_From_int((result));
21605 {
21606 if (temp2) delete arg2;
21607 }
21608 return resultobj;
21609 fail:
21610 {
21611 if (temp2) delete arg2;
21612 }
21613 return NULL;
21614 }
21615
21616
21617 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj;
21619 wxDateTime *arg1 = (wxDateTime *) 0 ;
21620 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21621 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21622 int result;
21623 bool temp2 = false ;
21624 PyObject * obj0 = 0 ;
21625 PyObject * obj1 = 0 ;
21626 char *kwnames[] = {
21627 (char *) "self",(char *) "tz", NULL
21628 };
21629
21630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 if (obj1) {
21634 {
21635 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21636 temp2 = true;
21637 }
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 {
21647 resultobj = SWIG_From_int((int)(result));
21648 }
21649 {
21650 if (temp2) delete arg2;
21651 }
21652 return resultobj;
21653 fail:
21654 {
21655 if (temp2) delete arg2;
21656 }
21657 return NULL;
21658 }
21659
21660
21661 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj;
21663 wxDateTime *arg1 = (wxDateTime *) 0 ;
21664 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21665 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21666 int result;
21667 bool temp2 = false ;
21668 PyObject * obj0 = 0 ;
21669 PyObject * obj1 = 0 ;
21670 char *kwnames[] = {
21671 (char *) "self",(char *) "tz", NULL
21672 };
21673
21674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21676 if (SWIG_arg_fail(1)) SWIG_fail;
21677 if (obj1) {
21678 {
21679 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21680 temp2 = true;
21681 }
21682 }
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21686
21687 wxPyEndAllowThreads(__tstate);
21688 if (PyErr_Occurred()) SWIG_fail;
21689 }
21690 {
21691 resultobj = SWIG_From_int((int)(result));
21692 }
21693 {
21694 if (temp2) delete arg2;
21695 }
21696 return resultobj;
21697 fail:
21698 {
21699 if (temp2) delete arg2;
21700 }
21701 return NULL;
21702 }
21703
21704
21705 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21706 PyObject *resultobj;
21707 wxDateTime *arg1 = (wxDateTime *) 0 ;
21708 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21709 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21710 int result;
21711 bool temp2 = false ;
21712 PyObject * obj0 = 0 ;
21713 PyObject * obj1 = 0 ;
21714 char *kwnames[] = {
21715 (char *) "self",(char *) "tz", NULL
21716 };
21717
21718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21720 if (SWIG_arg_fail(1)) SWIG_fail;
21721 if (obj1) {
21722 {
21723 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21724 temp2 = true;
21725 }
21726 }
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 {
21735 resultobj = SWIG_From_int((int)(result));
21736 }
21737 {
21738 if (temp2) delete arg2;
21739 }
21740 return resultobj;
21741 fail:
21742 {
21743 if (temp2) delete arg2;
21744 }
21745 return NULL;
21746 }
21747
21748
21749 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21750 PyObject *resultobj;
21751 wxDateTime *arg1 = (wxDateTime *) 0 ;
21752 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21753 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21754 int result;
21755 bool temp2 = false ;
21756 PyObject * obj0 = 0 ;
21757 PyObject * obj1 = 0 ;
21758 char *kwnames[] = {
21759 (char *) "self",(char *) "tz", NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(1)) SWIG_fail;
21765 if (obj1) {
21766 {
21767 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21768 temp2 = true;
21769 }
21770 }
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21774
21775 wxPyEndAllowThreads(__tstate);
21776 if (PyErr_Occurred()) SWIG_fail;
21777 }
21778 {
21779 resultobj = SWIG_From_int((int)(result));
21780 }
21781 {
21782 if (temp2) delete arg2;
21783 }
21784 return resultobj;
21785 fail:
21786 {
21787 if (temp2) delete arg2;
21788 }
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxDateTime *arg1 = (wxDateTime *) 0 ;
21796 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21797 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21798 int result;
21799 bool temp2 = false ;
21800 PyObject * obj0 = 0 ;
21801 PyObject * obj1 = 0 ;
21802 char *kwnames[] = {
21803 (char *) "self",(char *) "tz", NULL
21804 };
21805
21806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21808 if (SWIG_arg_fail(1)) SWIG_fail;
21809 if (obj1) {
21810 {
21811 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21812 temp2 = true;
21813 }
21814 }
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 {
21823 resultobj = SWIG_From_int((int)(result));
21824 }
21825 {
21826 if (temp2) delete arg2;
21827 }
21828 return resultobj;
21829 fail:
21830 {
21831 if (temp2) delete arg2;
21832 }
21833 return NULL;
21834 }
21835
21836
21837 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj;
21839 wxDateTime *arg1 = (wxDateTime *) 0 ;
21840 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21841 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21842 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21843 int result;
21844 bool temp3 = false ;
21845 PyObject * obj0 = 0 ;
21846 PyObject * obj1 = 0 ;
21847 PyObject * obj2 = 0 ;
21848 char *kwnames[] = {
21849 (char *) "self",(char *) "flags",(char *) "tz", NULL
21850 };
21851
21852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21854 if (SWIG_arg_fail(1)) SWIG_fail;
21855 if (obj1) {
21856 {
21857 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21858 if (SWIG_arg_fail(2)) SWIG_fail;
21859 }
21860 }
21861 if (obj2) {
21862 {
21863 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21864 temp3 = true;
21865 }
21866 }
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 {
21875 resultobj = SWIG_From_int((int)(result));
21876 }
21877 {
21878 if (temp3) delete arg3;
21879 }
21880 return resultobj;
21881 fail:
21882 {
21883 if (temp3) delete arg3;
21884 }
21885 return NULL;
21886 }
21887
21888
21889 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj;
21891 wxDateTime *arg1 = (wxDateTime *) 0 ;
21892 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21893 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21894 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21895 int result;
21896 bool temp3 = false ;
21897 PyObject * obj0 = 0 ;
21898 PyObject * obj1 = 0 ;
21899 PyObject * obj2 = 0 ;
21900 char *kwnames[] = {
21901 (char *) "self",(char *) "flags",(char *) "tz", NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(1)) SWIG_fail;
21907 if (obj1) {
21908 {
21909 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21910 if (SWIG_arg_fail(2)) SWIG_fail;
21911 }
21912 }
21913 if (obj2) {
21914 {
21915 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21916 temp3 = true;
21917 }
21918 }
21919 {
21920 PyThreadState* __tstate = wxPyBeginAllowThreads();
21921 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21922
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 {
21927 resultobj = SWIG_From_int((int)(result));
21928 }
21929 {
21930 if (temp3) delete arg3;
21931 }
21932 return resultobj;
21933 fail:
21934 {
21935 if (temp3) delete arg3;
21936 }
21937 return NULL;
21938 }
21939
21940
21941 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21942 PyObject *resultobj;
21943 wxDateTime *arg1 = (wxDateTime *) 0 ;
21944 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21945 bool result;
21946 PyObject * obj0 = 0 ;
21947 PyObject * obj1 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "country", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 if (obj1) {
21956 {
21957 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21958 if (SWIG_arg_fail(2)) SWIG_fail;
21959 }
21960 }
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21964
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 {
21969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21970 }
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21978 PyObject *resultobj;
21979 wxDateTime *arg1 = (wxDateTime *) 0 ;
21980 wxDateTime *arg2 = 0 ;
21981 bool result;
21982 PyObject * obj0 = 0 ;
21983 PyObject * obj1 = 0 ;
21984 char *kwnames[] = {
21985 (char *) "self",(char *) "datetime", NULL
21986 };
21987
21988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21990 if (SWIG_arg_fail(1)) SWIG_fail;
21991 {
21992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21993 if (SWIG_arg_fail(2)) SWIG_fail;
21994 if (arg2 == NULL) {
21995 SWIG_null_ref("wxDateTime");
21996 }
21997 if (SWIG_arg_fail(2)) SWIG_fail;
21998 }
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22002
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 {
22007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22008 }
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj;
22017 wxDateTime *arg1 = (wxDateTime *) 0 ;
22018 wxDateTime *arg2 = 0 ;
22019 bool result;
22020 PyObject * obj0 = 0 ;
22021 PyObject * obj1 = 0 ;
22022 char *kwnames[] = {
22023 (char *) "self",(char *) "datetime", NULL
22024 };
22025
22026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22028 if (SWIG_arg_fail(1)) SWIG_fail;
22029 {
22030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22031 if (SWIG_arg_fail(2)) SWIG_fail;
22032 if (arg2 == NULL) {
22033 SWIG_null_ref("wxDateTime");
22034 }
22035 if (SWIG_arg_fail(2)) SWIG_fail;
22036 }
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22040
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj;
22055 wxDateTime *arg1 = (wxDateTime *) 0 ;
22056 wxDateTime *arg2 = 0 ;
22057 bool result;
22058 PyObject * obj0 = 0 ;
22059 PyObject * obj1 = 0 ;
22060 char *kwnames[] = {
22061 (char *) "self",(char *) "datetime", NULL
22062 };
22063
22064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22066 if (SWIG_arg_fail(1)) SWIG_fail;
22067 {
22068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(2)) SWIG_fail;
22070 if (arg2 == NULL) {
22071 SWIG_null_ref("wxDateTime");
22072 }
22073 if (SWIG_arg_fail(2)) SWIG_fail;
22074 }
22075 {
22076 PyThreadState* __tstate = wxPyBeginAllowThreads();
22077 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22078
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22092 PyObject *resultobj;
22093 wxDateTime *arg1 = (wxDateTime *) 0 ;
22094 wxDateTime *arg2 = 0 ;
22095 wxDateTime *arg3 = 0 ;
22096 bool result;
22097 PyObject * obj0 = 0 ;
22098 PyObject * obj1 = 0 ;
22099 PyObject * obj2 = 0 ;
22100 char *kwnames[] = {
22101 (char *) "self",(char *) "t1",(char *) "t2", NULL
22102 };
22103
22104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(1)) SWIG_fail;
22107 {
22108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(2)) SWIG_fail;
22110 if (arg2 == NULL) {
22111 SWIG_null_ref("wxDateTime");
22112 }
22113 if (SWIG_arg_fail(2)) SWIG_fail;
22114 }
22115 {
22116 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(3)) SWIG_fail;
22118 if (arg3 == NULL) {
22119 SWIG_null_ref("wxDateTime");
22120 }
22121 if (SWIG_arg_fail(3)) SWIG_fail;
22122 }
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
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_IsBetween(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_IsBetween",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)->IsBetween((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_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22188 PyObject *resultobj;
22189 wxDateTime *arg1 = (wxDateTime *) 0 ;
22190 wxDateTime *arg2 = 0 ;
22191 bool result;
22192 PyObject * obj0 = 0 ;
22193 PyObject * obj1 = 0 ;
22194 char *kwnames[] = {
22195 (char *) "self",(char *) "dt", NULL
22196 };
22197
22198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22200 if (SWIG_arg_fail(1)) SWIG_fail;
22201 {
22202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22203 if (SWIG_arg_fail(2)) SWIG_fail;
22204 if (arg2 == NULL) {
22205 SWIG_null_ref("wxDateTime");
22206 }
22207 if (SWIG_arg_fail(2)) SWIG_fail;
22208 }
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22212
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 {
22217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22218 }
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22226 PyObject *resultobj;
22227 wxDateTime *arg1 = (wxDateTime *) 0 ;
22228 wxDateTime *arg2 = 0 ;
22229 bool result;
22230 PyObject * obj0 = 0 ;
22231 PyObject * obj1 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "self",(char *) "dt", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(1)) SWIG_fail;
22239 {
22240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(2)) SWIG_fail;
22242 if (arg2 == NULL) {
22243 SWIG_null_ref("wxDateTime");
22244 }
22245 if (SWIG_arg_fail(2)) SWIG_fail;
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 {
22255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxDateTime *arg1 = (wxDateTime *) 0 ;
22266 wxDateTime *arg2 = 0 ;
22267 wxTimeSpan *arg3 = 0 ;
22268 bool result;
22269 PyObject * obj0 = 0 ;
22270 PyObject * obj1 = 0 ;
22271 PyObject * obj2 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self",(char *) "dt",(char *) "ts", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22281 if (SWIG_arg_fail(2)) SWIG_fail;
22282 if (arg2 == NULL) {
22283 SWIG_null_ref("wxDateTime");
22284 }
22285 if (SWIG_arg_fail(2)) SWIG_fail;
22286 }
22287 {
22288 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(3)) SWIG_fail;
22290 if (arg3 == NULL) {
22291 SWIG_null_ref("wxTimeSpan");
22292 }
22293 if (SWIG_arg_fail(3)) SWIG_fail;
22294 }
22295 {
22296 PyThreadState* __tstate = wxPyBeginAllowThreads();
22297 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
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_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22312 PyObject *resultobj;
22313 wxDateTime *arg1 = (wxDateTime *) 0 ;
22314 wxTimeSpan *arg2 = 0 ;
22315 wxDateTime *result;
22316 PyObject * obj0 = 0 ;
22317 PyObject * obj1 = 0 ;
22318 char *kwnames[] = {
22319 (char *) "self",(char *) "diff", NULL
22320 };
22321
22322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22324 if (SWIG_arg_fail(1)) SWIG_fail;
22325 {
22326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(2)) SWIG_fail;
22328 if (arg2 == NULL) {
22329 SWIG_null_ref("wxTimeSpan");
22330 }
22331 if (SWIG_arg_fail(2)) SWIG_fail;
22332 }
22333 {
22334 PyThreadState* __tstate = wxPyBeginAllowThreads();
22335 {
22336 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22337 result = (wxDateTime *) &_result_ref;
22338 }
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22351 PyObject *resultobj;
22352 wxDateTime *arg1 = (wxDateTime *) 0 ;
22353 wxDateSpan *arg2 = 0 ;
22354 wxDateTime *result;
22355 PyObject * obj0 = 0 ;
22356 PyObject * obj1 = 0 ;
22357 char *kwnames[] = {
22358 (char *) "self",(char *) "diff", NULL
22359 };
22360
22361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22363 if (SWIG_arg_fail(1)) SWIG_fail;
22364 {
22365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(2)) SWIG_fail;
22367 if (arg2 == NULL) {
22368 SWIG_null_ref("wxDateSpan");
22369 }
22370 if (SWIG_arg_fail(2)) SWIG_fail;
22371 }
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 {
22375 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22376 result = (wxDateTime *) &_result_ref;
22377 }
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22390 PyObject *resultobj;
22391 wxDateTime *arg1 = (wxDateTime *) 0 ;
22392 wxTimeSpan *arg2 = 0 ;
22393 wxDateTime *result;
22394 PyObject * obj0 = 0 ;
22395 PyObject * obj1 = 0 ;
22396 char *kwnames[] = {
22397 (char *) "self",(char *) "diff", NULL
22398 };
22399
22400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(1)) SWIG_fail;
22403 {
22404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(2)) SWIG_fail;
22406 if (arg2 == NULL) {
22407 SWIG_null_ref("wxTimeSpan");
22408 }
22409 if (SWIG_arg_fail(2)) SWIG_fail;
22410 }
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 {
22414 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22415 result = (wxDateTime *) &_result_ref;
22416 }
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxDateTime *arg1 = (wxDateTime *) 0 ;
22431 wxDateSpan *arg2 = 0 ;
22432 wxDateTime *result;
22433 PyObject * obj0 = 0 ;
22434 PyObject * obj1 = 0 ;
22435 char *kwnames[] = {
22436 (char *) "self",(char *) "diff", NULL
22437 };
22438
22439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(1)) SWIG_fail;
22442 {
22443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(2)) SWIG_fail;
22445 if (arg2 == NULL) {
22446 SWIG_null_ref("wxDateSpan");
22447 }
22448 if (SWIG_arg_fail(2)) SWIG_fail;
22449 }
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 {
22453 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22454 result = (wxDateTime *) &_result_ref;
22455 }
22456
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22468 PyObject *resultobj;
22469 wxDateTime *arg1 = (wxDateTime *) 0 ;
22470 wxDateTime *arg2 = 0 ;
22471 wxTimeSpan result;
22472 PyObject * obj0 = 0 ;
22473 PyObject * obj1 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self",(char *) "dt", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 if (arg2 == NULL) {
22485 SWIG_null_ref("wxDateTime");
22486 }
22487 if (SWIG_arg_fail(2)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 {
22497 wxTimeSpan * resultptr;
22498 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22500 }
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22508 PyObject *resultobj;
22509 wxDateTime *arg1 = (wxDateTime *) 0 ;
22510 wxTimeSpan *arg2 = 0 ;
22511 wxDateTime *result;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514
22515 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22517 if (SWIG_arg_fail(1)) SWIG_fail;
22518 {
22519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 if (arg2 == NULL) {
22522 SWIG_null_ref("wxTimeSpan");
22523 }
22524 if (SWIG_arg_fail(2)) SWIG_fail;
22525 }
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 {
22529 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22530 result = (wxDateTime *) &_result_ref;
22531 }
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22544 PyObject *resultobj;
22545 wxDateTime *arg1 = (wxDateTime *) 0 ;
22546 wxDateSpan *arg2 = 0 ;
22547 wxDateTime *result;
22548 PyObject * obj0 = 0 ;
22549 PyObject * obj1 = 0 ;
22550
22551 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22553 if (SWIG_arg_fail(1)) SWIG_fail;
22554 {
22555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22556 if (SWIG_arg_fail(2)) SWIG_fail;
22557 if (arg2 == NULL) {
22558 SWIG_null_ref("wxDateSpan");
22559 }
22560 if (SWIG_arg_fail(2)) SWIG_fail;
22561 }
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 {
22565 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22566 result = (wxDateTime *) &_result_ref;
22567 }
22568
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22580 int argc;
22581 PyObject *argv[3];
22582 int ii;
22583
22584 argc = PyObject_Length(args);
22585 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22586 argv[ii] = PyTuple_GetItem(args,ii);
22587 }
22588 if (argc == 2) {
22589 int _v;
22590 {
22591 void *ptr;
22592 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22593 _v = 0;
22594 PyErr_Clear();
22595 } else {
22596 _v = 1;
22597 }
22598 }
22599 if (_v) {
22600 {
22601 void *ptr = 0;
22602 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22603 _v = 0;
22604 PyErr_Clear();
22605 } else {
22606 _v = (ptr != 0);
22607 }
22608 }
22609 if (_v) {
22610 return _wrap_DateTime___iadd____SWIG_0(self,args);
22611 }
22612 }
22613 }
22614 if (argc == 2) {
22615 int _v;
22616 {
22617 void *ptr;
22618 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22619 _v = 0;
22620 PyErr_Clear();
22621 } else {
22622 _v = 1;
22623 }
22624 }
22625 if (_v) {
22626 {
22627 void *ptr = 0;
22628 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22629 _v = 0;
22630 PyErr_Clear();
22631 } else {
22632 _v = (ptr != 0);
22633 }
22634 }
22635 if (_v) {
22636 return _wrap_DateTime___iadd____SWIG_1(self,args);
22637 }
22638 }
22639 }
22640
22641 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22642 return NULL;
22643 }
22644
22645
22646 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22647 PyObject *resultobj;
22648 wxDateTime *arg1 = (wxDateTime *) 0 ;
22649 wxTimeSpan *arg2 = 0 ;
22650 wxDateTime *result;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653
22654 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22656 if (SWIG_arg_fail(1)) SWIG_fail;
22657 {
22658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(2)) SWIG_fail;
22660 if (arg2 == NULL) {
22661 SWIG_null_ref("wxTimeSpan");
22662 }
22663 if (SWIG_arg_fail(2)) SWIG_fail;
22664 }
22665 {
22666 PyThreadState* __tstate = wxPyBeginAllowThreads();
22667 {
22668 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22669 result = (wxDateTime *) &_result_ref;
22670 }
22671
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22683 PyObject *resultobj;
22684 wxDateTime *arg1 = (wxDateTime *) 0 ;
22685 wxDateSpan *arg2 = 0 ;
22686 wxDateTime *result;
22687 PyObject * obj0 = 0 ;
22688 PyObject * obj1 = 0 ;
22689
22690 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22692 if (SWIG_arg_fail(1)) SWIG_fail;
22693 {
22694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22695 if (SWIG_arg_fail(2)) SWIG_fail;
22696 if (arg2 == NULL) {
22697 SWIG_null_ref("wxDateSpan");
22698 }
22699 if (SWIG_arg_fail(2)) SWIG_fail;
22700 }
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 {
22704 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22705 result = (wxDateTime *) &_result_ref;
22706 }
22707
22708 wxPyEndAllowThreads(__tstate);
22709 if (PyErr_Occurred()) SWIG_fail;
22710 }
22711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22719 int argc;
22720 PyObject *argv[3];
22721 int ii;
22722
22723 argc = PyObject_Length(args);
22724 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22725 argv[ii] = PyTuple_GetItem(args,ii);
22726 }
22727 if (argc == 2) {
22728 int _v;
22729 {
22730 void *ptr;
22731 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22732 _v = 0;
22733 PyErr_Clear();
22734 } else {
22735 _v = 1;
22736 }
22737 }
22738 if (_v) {
22739 {
22740 void *ptr = 0;
22741 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22742 _v = 0;
22743 PyErr_Clear();
22744 } else {
22745 _v = (ptr != 0);
22746 }
22747 }
22748 if (_v) {
22749 return _wrap_DateTime___isub____SWIG_0(self,args);
22750 }
22751 }
22752 }
22753 if (argc == 2) {
22754 int _v;
22755 {
22756 void *ptr;
22757 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22758 _v = 0;
22759 PyErr_Clear();
22760 } else {
22761 _v = 1;
22762 }
22763 }
22764 if (_v) {
22765 {
22766 void *ptr = 0;
22767 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22768 _v = 0;
22769 PyErr_Clear();
22770 } else {
22771 _v = (ptr != 0);
22772 }
22773 }
22774 if (_v) {
22775 return _wrap_DateTime___isub____SWIG_1(self,args);
22776 }
22777 }
22778 }
22779
22780 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22781 return NULL;
22782 }
22783
22784
22785 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22786 PyObject *resultobj;
22787 wxDateTime *arg1 = (wxDateTime *) 0 ;
22788 wxTimeSpan *arg2 = 0 ;
22789 wxDateTime result;
22790 PyObject * obj0 = 0 ;
22791 PyObject * obj1 = 0 ;
22792
22793 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(1)) SWIG_fail;
22796 {
22797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(2)) SWIG_fail;
22799 if (arg2 == NULL) {
22800 SWIG_null_ref("wxTimeSpan");
22801 }
22802 if (SWIG_arg_fail(2)) SWIG_fail;
22803 }
22804 {
22805 PyThreadState* __tstate = wxPyBeginAllowThreads();
22806 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22807
22808 wxPyEndAllowThreads(__tstate);
22809 if (PyErr_Occurred()) SWIG_fail;
22810 }
22811 {
22812 wxDateTime * resultptr;
22813 resultptr = new wxDateTime((wxDateTime &)(result));
22814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22815 }
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22823 PyObject *resultobj;
22824 wxDateTime *arg1 = (wxDateTime *) 0 ;
22825 wxDateSpan *arg2 = 0 ;
22826 wxDateTime result;
22827 PyObject * obj0 = 0 ;
22828 PyObject * obj1 = 0 ;
22829
22830 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22832 if (SWIG_arg_fail(1)) SWIG_fail;
22833 {
22834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22835 if (SWIG_arg_fail(2)) SWIG_fail;
22836 if (arg2 == NULL) {
22837 SWIG_null_ref("wxDateSpan");
22838 }
22839 if (SWIG_arg_fail(2)) SWIG_fail;
22840 }
22841 {
22842 PyThreadState* __tstate = wxPyBeginAllowThreads();
22843 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22844
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 {
22849 wxDateTime * resultptr;
22850 resultptr = new wxDateTime((wxDateTime &)(result));
22851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22852 }
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22860 int argc;
22861 PyObject *argv[3];
22862 int ii;
22863
22864 argc = PyObject_Length(args);
22865 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22866 argv[ii] = PyTuple_GetItem(args,ii);
22867 }
22868 if (argc == 2) {
22869 int _v;
22870 {
22871 void *ptr;
22872 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22873 _v = 0;
22874 PyErr_Clear();
22875 } else {
22876 _v = 1;
22877 }
22878 }
22879 if (_v) {
22880 {
22881 void *ptr = 0;
22882 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22883 _v = 0;
22884 PyErr_Clear();
22885 } else {
22886 _v = (ptr != 0);
22887 }
22888 }
22889 if (_v) {
22890 return _wrap_DateTime___add____SWIG_0(self,args);
22891 }
22892 }
22893 }
22894 if (argc == 2) {
22895 int _v;
22896 {
22897 void *ptr;
22898 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22899 _v = 0;
22900 PyErr_Clear();
22901 } else {
22902 _v = 1;
22903 }
22904 }
22905 if (_v) {
22906 {
22907 void *ptr = 0;
22908 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22909 _v = 0;
22910 PyErr_Clear();
22911 } else {
22912 _v = (ptr != 0);
22913 }
22914 }
22915 if (_v) {
22916 return _wrap_DateTime___add____SWIG_1(self,args);
22917 }
22918 }
22919 }
22920
22921 Py_INCREF(Py_NotImplemented);
22922 return Py_NotImplemented;
22923 }
22924
22925
22926 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22927 PyObject *resultobj;
22928 wxDateTime *arg1 = (wxDateTime *) 0 ;
22929 wxDateTime *arg2 = 0 ;
22930 wxTimeSpan result;
22931 PyObject * obj0 = 0 ;
22932 PyObject * obj1 = 0 ;
22933
22934 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22936 if (SWIG_arg_fail(1)) SWIG_fail;
22937 {
22938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22939 if (SWIG_arg_fail(2)) SWIG_fail;
22940 if (arg2 == NULL) {
22941 SWIG_null_ref("wxDateTime");
22942 }
22943 if (SWIG_arg_fail(2)) SWIG_fail;
22944 }
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 wxTimeSpan * resultptr;
22954 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22956 }
22957 return resultobj;
22958 fail:
22959 return NULL;
22960 }
22961
22962
22963 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22964 PyObject *resultobj;
22965 wxDateTime *arg1 = (wxDateTime *) 0 ;
22966 wxTimeSpan *arg2 = 0 ;
22967 wxDateTime result;
22968 PyObject * obj0 = 0 ;
22969 PyObject * obj1 = 0 ;
22970
22971 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 {
22975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22976 if (SWIG_arg_fail(2)) SWIG_fail;
22977 if (arg2 == NULL) {
22978 SWIG_null_ref("wxTimeSpan");
22979 }
22980 if (SWIG_arg_fail(2)) SWIG_fail;
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22985
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 {
22990 wxDateTime * resultptr;
22991 resultptr = new wxDateTime((wxDateTime &)(result));
22992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22993 }
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23001 PyObject *resultobj;
23002 wxDateTime *arg1 = (wxDateTime *) 0 ;
23003 wxDateSpan *arg2 = 0 ;
23004 wxDateTime result;
23005 PyObject * obj0 = 0 ;
23006 PyObject * obj1 = 0 ;
23007
23008 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23010 if (SWIG_arg_fail(1)) SWIG_fail;
23011 {
23012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23013 if (SWIG_arg_fail(2)) SWIG_fail;
23014 if (arg2 == NULL) {
23015 SWIG_null_ref("wxDateSpan");
23016 }
23017 if (SWIG_arg_fail(2)) SWIG_fail;
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23022
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 {
23027 wxDateTime * resultptr;
23028 resultptr = new wxDateTime((wxDateTime &)(result));
23029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23030 }
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23038 int argc;
23039 PyObject *argv[3];
23040 int ii;
23041
23042 argc = PyObject_Length(args);
23043 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23044 argv[ii] = PyTuple_GetItem(args,ii);
23045 }
23046 if (argc == 2) {
23047 int _v;
23048 {
23049 void *ptr;
23050 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23051 _v = 0;
23052 PyErr_Clear();
23053 } else {
23054 _v = 1;
23055 }
23056 }
23057 if (_v) {
23058 {
23059 void *ptr = 0;
23060 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23061 _v = 0;
23062 PyErr_Clear();
23063 } else {
23064 _v = (ptr != 0);
23065 }
23066 }
23067 if (_v) {
23068 return _wrap_DateTime___sub____SWIG_0(self,args);
23069 }
23070 }
23071 }
23072 if (argc == 2) {
23073 int _v;
23074 {
23075 void *ptr;
23076 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23077 _v = 0;
23078 PyErr_Clear();
23079 } else {
23080 _v = 1;
23081 }
23082 }
23083 if (_v) {
23084 {
23085 void *ptr = 0;
23086 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23087 _v = 0;
23088 PyErr_Clear();
23089 } else {
23090 _v = (ptr != 0);
23091 }
23092 }
23093 if (_v) {
23094 return _wrap_DateTime___sub____SWIG_1(self,args);
23095 }
23096 }
23097 }
23098 if (argc == 2) {
23099 int _v;
23100 {
23101 void *ptr;
23102 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23103 _v = 0;
23104 PyErr_Clear();
23105 } else {
23106 _v = 1;
23107 }
23108 }
23109 if (_v) {
23110 {
23111 void *ptr = 0;
23112 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23113 _v = 0;
23114 PyErr_Clear();
23115 } else {
23116 _v = (ptr != 0);
23117 }
23118 }
23119 if (_v) {
23120 return _wrap_DateTime___sub____SWIG_2(self,args);
23121 }
23122 }
23123 }
23124
23125 Py_INCREF(Py_NotImplemented);
23126 return Py_NotImplemented;
23127 }
23128
23129
23130 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23131 PyObject *resultobj;
23132 wxDateTime *arg1 = (wxDateTime *) 0 ;
23133 wxDateTime *arg2 = (wxDateTime *) 0 ;
23134 bool result;
23135 PyObject * obj0 = 0 ;
23136 PyObject * obj1 = 0 ;
23137 char *kwnames[] = {
23138 (char *) "self",(char *) "other", NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(1)) SWIG_fail;
23144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(2)) SWIG_fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 {
23154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23155 }
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23163 PyObject *resultobj;
23164 wxDateTime *arg1 = (wxDateTime *) 0 ;
23165 wxDateTime *arg2 = (wxDateTime *) 0 ;
23166 bool result;
23167 PyObject * obj0 = 0 ;
23168 PyObject * obj1 = 0 ;
23169 char *kwnames[] = {
23170 (char *) "self",(char *) "other", NULL
23171 };
23172
23173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23175 if (SWIG_arg_fail(1)) SWIG_fail;
23176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23177 if (SWIG_arg_fail(2)) SWIG_fail;
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj;
23196 wxDateTime *arg1 = (wxDateTime *) 0 ;
23197 wxDateTime *arg2 = (wxDateTime *) 0 ;
23198 bool result;
23199 PyObject * obj0 = 0 ;
23200 PyObject * obj1 = 0 ;
23201 char *kwnames[] = {
23202 (char *) "self",(char *) "other", NULL
23203 };
23204
23205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23207 if (SWIG_arg_fail(1)) SWIG_fail;
23208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23209 if (SWIG_arg_fail(2)) SWIG_fail;
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 {
23218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23219 }
23220 return resultobj;
23221 fail:
23222 return NULL;
23223 }
23224
23225
23226 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23227 PyObject *resultobj;
23228 wxDateTime *arg1 = (wxDateTime *) 0 ;
23229 wxDateTime *arg2 = (wxDateTime *) 0 ;
23230 bool result;
23231 PyObject * obj0 = 0 ;
23232 PyObject * obj1 = 0 ;
23233 char *kwnames[] = {
23234 (char *) "self",(char *) "other", NULL
23235 };
23236
23237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23239 if (SWIG_arg_fail(1)) SWIG_fail;
23240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23241 if (SWIG_arg_fail(2)) SWIG_fail;
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 wxDateTime *arg1 = (wxDateTime *) 0 ;
23261 wxDateTime *arg2 = (wxDateTime *) 0 ;
23262 bool result;
23263 PyObject * obj0 = 0 ;
23264 PyObject * obj1 = 0 ;
23265 char *kwnames[] = {
23266 (char *) "self",(char *) "other", NULL
23267 };
23268
23269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23271 if (SWIG_arg_fail(1)) SWIG_fail;
23272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23273 if (SWIG_arg_fail(2)) SWIG_fail;
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23277
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 {
23282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23283 }
23284 return resultobj;
23285 fail:
23286 return NULL;
23287 }
23288
23289
23290 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23291 PyObject *resultobj;
23292 wxDateTime *arg1 = (wxDateTime *) 0 ;
23293 wxDateTime *arg2 = (wxDateTime *) 0 ;
23294 bool result;
23295 PyObject * obj0 = 0 ;
23296 PyObject * obj1 = 0 ;
23297 char *kwnames[] = {
23298 (char *) "self",(char *) "other", NULL
23299 };
23300
23301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23303 if (SWIG_arg_fail(1)) SWIG_fail;
23304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23305 if (SWIG_arg_fail(2)) SWIG_fail;
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23309
23310 wxPyEndAllowThreads(__tstate);
23311 if (PyErr_Occurred()) SWIG_fail;
23312 }
23313 {
23314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23315 }
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj;
23324 wxDateTime *arg1 = (wxDateTime *) 0 ;
23325 wxString *arg2 = 0 ;
23326 int result;
23327 bool temp2 = false ;
23328 PyObject * obj0 = 0 ;
23329 PyObject * obj1 = 0 ;
23330 char *kwnames[] = {
23331 (char *) "self",(char *) "date", NULL
23332 };
23333
23334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23336 if (SWIG_arg_fail(1)) SWIG_fail;
23337 {
23338 arg2 = wxString_in_helper(obj1);
23339 if (arg2 == NULL) SWIG_fail;
23340 temp2 = true;
23341 }
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = SWIG_From_int((int)(result));
23351 }
23352 {
23353 if (temp2)
23354 delete arg2;
23355 }
23356 return resultobj;
23357 fail:
23358 {
23359 if (temp2)
23360 delete arg2;
23361 }
23362 return NULL;
23363 }
23364
23365
23366 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23367 PyObject *resultobj;
23368 wxDateTime *arg1 = (wxDateTime *) 0 ;
23369 wxString *arg2 = 0 ;
23370 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23371 wxString *arg3 = (wxString *) &arg3_defvalue ;
23372 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23373 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23374 int result;
23375 bool temp2 = false ;
23376 bool temp3 = false ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 PyObject * obj2 = 0 ;
23380 PyObject * obj3 = 0 ;
23381 char *kwnames[] = {
23382 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23383 };
23384
23385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23387 if (SWIG_arg_fail(1)) SWIG_fail;
23388 {
23389 arg2 = wxString_in_helper(obj1);
23390 if (arg2 == NULL) SWIG_fail;
23391 temp2 = true;
23392 }
23393 if (obj2) {
23394 {
23395 arg3 = wxString_in_helper(obj2);
23396 if (arg3 == NULL) SWIG_fail;
23397 temp3 = true;
23398 }
23399 }
23400 if (obj3) {
23401 {
23402 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23403 if (SWIG_arg_fail(4)) SWIG_fail;
23404 if (arg4 == NULL) {
23405 SWIG_null_ref("wxDateTime");
23406 }
23407 if (SWIG_arg_fail(4)) SWIG_fail;
23408 }
23409 }
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23413
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = SWIG_From_int((int)(result));
23419 }
23420 {
23421 if (temp2)
23422 delete arg2;
23423 }
23424 {
23425 if (temp3)
23426 delete arg3;
23427 }
23428 return resultobj;
23429 fail:
23430 {
23431 if (temp2)
23432 delete arg2;
23433 }
23434 {
23435 if (temp3)
23436 delete arg3;
23437 }
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 wxDateTime *arg1 = (wxDateTime *) 0 ;
23445 wxString *arg2 = 0 ;
23446 int result;
23447 bool temp2 = false ;
23448 PyObject * obj0 = 0 ;
23449 PyObject * obj1 = 0 ;
23450 char *kwnames[] = {
23451 (char *) "self",(char *) "datetime", NULL
23452 };
23453
23454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23456 if (SWIG_arg_fail(1)) SWIG_fail;
23457 {
23458 arg2 = wxString_in_helper(obj1);
23459 if (arg2 == NULL) SWIG_fail;
23460 temp2 = true;
23461 }
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 resultobj = SWIG_From_int((int)(result));
23471 }
23472 {
23473 if (temp2)
23474 delete arg2;
23475 }
23476 return resultobj;
23477 fail:
23478 {
23479 if (temp2)
23480 delete arg2;
23481 }
23482 return NULL;
23483 }
23484
23485
23486 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23487 PyObject *resultobj;
23488 wxDateTime *arg1 = (wxDateTime *) 0 ;
23489 wxString *arg2 = 0 ;
23490 int result;
23491 bool temp2 = false ;
23492 PyObject * obj0 = 0 ;
23493 PyObject * obj1 = 0 ;
23494 char *kwnames[] = {
23495 (char *) "self",(char *) "date", NULL
23496 };
23497
23498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(1)) SWIG_fail;
23501 {
23502 arg2 = wxString_in_helper(obj1);
23503 if (arg2 == NULL) SWIG_fail;
23504 temp2 = true;
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 {
23514 resultobj = SWIG_From_int((int)(result));
23515 }
23516 {
23517 if (temp2)
23518 delete arg2;
23519 }
23520 return resultobj;
23521 fail:
23522 {
23523 if (temp2)
23524 delete arg2;
23525 }
23526 return NULL;
23527 }
23528
23529
23530 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23531 PyObject *resultobj;
23532 wxDateTime *arg1 = (wxDateTime *) 0 ;
23533 wxString *arg2 = 0 ;
23534 int result;
23535 bool temp2 = false ;
23536 PyObject * obj0 = 0 ;
23537 PyObject * obj1 = 0 ;
23538 char *kwnames[] = {
23539 (char *) "self",(char *) "time", NULL
23540 };
23541
23542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23544 if (SWIG_arg_fail(1)) SWIG_fail;
23545 {
23546 arg2 = wxString_in_helper(obj1);
23547 if (arg2 == NULL) SWIG_fail;
23548 temp2 = true;
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 {
23558 resultobj = SWIG_From_int((int)(result));
23559 }
23560 {
23561 if (temp2)
23562 delete arg2;
23563 }
23564 return resultobj;
23565 fail:
23566 {
23567 if (temp2)
23568 delete arg2;
23569 }
23570 return NULL;
23571 }
23572
23573
23574 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj;
23576 wxDateTime *arg1 = (wxDateTime *) 0 ;
23577 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23578 wxString *arg2 = (wxString *) &arg2_defvalue ;
23579 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23580 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23581 wxString result;
23582 bool temp2 = false ;
23583 bool temp3 = false ;
23584 PyObject * obj0 = 0 ;
23585 PyObject * obj1 = 0 ;
23586 PyObject * obj2 = 0 ;
23587 char *kwnames[] = {
23588 (char *) "self",(char *) "format",(char *) "tz", NULL
23589 };
23590
23591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23593 if (SWIG_arg_fail(1)) SWIG_fail;
23594 if (obj1) {
23595 {
23596 arg2 = wxString_in_helper(obj1);
23597 if (arg2 == NULL) SWIG_fail;
23598 temp2 = true;
23599 }
23600 }
23601 if (obj2) {
23602 {
23603 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23604 temp3 = true;
23605 }
23606 }
23607 {
23608 PyThreadState* __tstate = wxPyBeginAllowThreads();
23609 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23610
23611 wxPyEndAllowThreads(__tstate);
23612 if (PyErr_Occurred()) SWIG_fail;
23613 }
23614 {
23615 #if wxUSE_UNICODE
23616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23617 #else
23618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23619 #endif
23620 }
23621 {
23622 if (temp2)
23623 delete arg2;
23624 }
23625 {
23626 if (temp3) delete arg3;
23627 }
23628 return resultobj;
23629 fail:
23630 {
23631 if (temp2)
23632 delete arg2;
23633 }
23634 {
23635 if (temp3) delete arg3;
23636 }
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj;
23643 wxDateTime *arg1 = (wxDateTime *) 0 ;
23644 wxString result;
23645 PyObject * obj0 = 0 ;
23646 char *kwnames[] = {
23647 (char *) "self", NULL
23648 };
23649
23650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23652 if (SWIG_arg_fail(1)) SWIG_fail;
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 result = ((wxDateTime const *)arg1)->FormatDate();
23656
23657 wxPyEndAllowThreads(__tstate);
23658 if (PyErr_Occurred()) SWIG_fail;
23659 }
23660 {
23661 #if wxUSE_UNICODE
23662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23663 #else
23664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23665 #endif
23666 }
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj;
23675 wxDateTime *arg1 = (wxDateTime *) 0 ;
23676 wxString result;
23677 PyObject * obj0 = 0 ;
23678 char *kwnames[] = {
23679 (char *) "self", NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23684 if (SWIG_arg_fail(1)) SWIG_fail;
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = ((wxDateTime const *)arg1)->FormatTime();
23688
23689 wxPyEndAllowThreads(__tstate);
23690 if (PyErr_Occurred()) SWIG_fail;
23691 }
23692 {
23693 #if wxUSE_UNICODE
23694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23695 #else
23696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23697 #endif
23698 }
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23706 PyObject *resultobj;
23707 wxDateTime *arg1 = (wxDateTime *) 0 ;
23708 wxString result;
23709 PyObject * obj0 = 0 ;
23710 char *kwnames[] = {
23711 (char *) "self", NULL
23712 };
23713
23714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23716 if (SWIG_arg_fail(1)) SWIG_fail;
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = ((wxDateTime const *)arg1)->FormatISODate();
23720
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 #if wxUSE_UNICODE
23726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23727 #else
23728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23729 #endif
23730 }
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj;
23739 wxDateTime *arg1 = (wxDateTime *) 0 ;
23740 wxString result;
23741 PyObject * obj0 = 0 ;
23742 char *kwnames[] = {
23743 (char *) "self", NULL
23744 };
23745
23746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23748 if (SWIG_arg_fail(1)) SWIG_fail;
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = ((wxDateTime const *)arg1)->FormatISOTime();
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 {
23757 #if wxUSE_UNICODE
23758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23759 #else
23760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23761 #endif
23762 }
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23770 PyObject *obj;
23771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23772 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23773 Py_INCREF(obj);
23774 return Py_BuildValue((char *)"");
23775 }
23776 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23777 PyObject *resultobj;
23778 long arg1 ;
23779 wxTimeSpan result;
23780 PyObject * obj0 = 0 ;
23781 char *kwnames[] = {
23782 (char *) "sec", NULL
23783 };
23784
23785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23786 {
23787 arg1 = (long)(SWIG_As_long(obj0));
23788 if (SWIG_arg_fail(1)) SWIG_fail;
23789 }
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = wxTimeSpan::Seconds(arg1);
23793
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 {
23798 wxTimeSpan * resultptr;
23799 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23809 PyObject *resultobj;
23810 wxTimeSpan result;
23811 char *kwnames[] = {
23812 NULL
23813 };
23814
23815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = wxTimeSpan::Second();
23819
23820 wxPyEndAllowThreads(__tstate);
23821 if (PyErr_Occurred()) SWIG_fail;
23822 }
23823 {
23824 wxTimeSpan * resultptr;
23825 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23827 }
23828 return resultobj;
23829 fail:
23830 return NULL;
23831 }
23832
23833
23834 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23835 PyObject *resultobj;
23836 long arg1 ;
23837 wxTimeSpan result;
23838 PyObject * obj0 = 0 ;
23839 char *kwnames[] = {
23840 (char *) "min", NULL
23841 };
23842
23843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23844 {
23845 arg1 = (long)(SWIG_As_long(obj0));
23846 if (SWIG_arg_fail(1)) SWIG_fail;
23847 }
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 result = wxTimeSpan::Minutes(arg1);
23851
23852 wxPyEndAllowThreads(__tstate);
23853 if (PyErr_Occurred()) SWIG_fail;
23854 }
23855 {
23856 wxTimeSpan * resultptr;
23857 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23859 }
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23867 PyObject *resultobj;
23868 wxTimeSpan result;
23869 char *kwnames[] = {
23870 NULL
23871 };
23872
23873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = wxTimeSpan::Minute();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 {
23882 wxTimeSpan * resultptr;
23883 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23885 }
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 long arg1 ;
23895 wxTimeSpan result;
23896 PyObject * obj0 = 0 ;
23897 char *kwnames[] = {
23898 (char *) "hours", NULL
23899 };
23900
23901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23902 {
23903 arg1 = (long)(SWIG_As_long(obj0));
23904 if (SWIG_arg_fail(1)) SWIG_fail;
23905 }
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = wxTimeSpan::Hours(arg1);
23909
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 {
23914 wxTimeSpan * resultptr;
23915 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23917 }
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj;
23926 wxTimeSpan result;
23927 char *kwnames[] = {
23928 NULL
23929 };
23930
23931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 result = wxTimeSpan::Hour();
23935
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 {
23940 wxTimeSpan * resultptr;
23941 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23943 }
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj;
23952 long arg1 ;
23953 wxTimeSpan result;
23954 PyObject * obj0 = 0 ;
23955 char *kwnames[] = {
23956 (char *) "days", NULL
23957 };
23958
23959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23960 {
23961 arg1 = (long)(SWIG_As_long(obj0));
23962 if (SWIG_arg_fail(1)) SWIG_fail;
23963 }
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = wxTimeSpan::Days(arg1);
23967
23968 wxPyEndAllowThreads(__tstate);
23969 if (PyErr_Occurred()) SWIG_fail;
23970 }
23971 {
23972 wxTimeSpan * resultptr;
23973 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23975 }
23976 return resultobj;
23977 fail:
23978 return NULL;
23979 }
23980
23981
23982 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23983 PyObject *resultobj;
23984 wxTimeSpan result;
23985 char *kwnames[] = {
23986 NULL
23987 };
23988
23989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = wxTimeSpan::Day();
23993
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 {
23998 wxTimeSpan * resultptr;
23999 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24001 }
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24009 PyObject *resultobj;
24010 long arg1 ;
24011 wxTimeSpan result;
24012 PyObject * obj0 = 0 ;
24013 char *kwnames[] = {
24014 (char *) "days", NULL
24015 };
24016
24017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24018 {
24019 arg1 = (long)(SWIG_As_long(obj0));
24020 if (SWIG_arg_fail(1)) SWIG_fail;
24021 }
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 result = wxTimeSpan::Weeks(arg1);
24025
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 {
24030 wxTimeSpan * resultptr;
24031 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24033 }
24034 return resultobj;
24035 fail:
24036 return NULL;
24037 }
24038
24039
24040 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24041 PyObject *resultobj;
24042 wxTimeSpan result;
24043 char *kwnames[] = {
24044 NULL
24045 };
24046
24047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 result = wxTimeSpan::Week();
24051
24052 wxPyEndAllowThreads(__tstate);
24053 if (PyErr_Occurred()) SWIG_fail;
24054 }
24055 {
24056 wxTimeSpan * resultptr;
24057 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24059 }
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24067 PyObject *resultobj;
24068 long arg1 = (long) 0 ;
24069 long arg2 = (long) 0 ;
24070 long arg3 = (long) 0 ;
24071 long arg4 = (long) 0 ;
24072 wxTimeSpan *result;
24073 PyObject * obj0 = 0 ;
24074 PyObject * obj1 = 0 ;
24075 PyObject * obj2 = 0 ;
24076 PyObject * obj3 = 0 ;
24077 char *kwnames[] = {
24078 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24079 };
24080
24081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24082 if (obj0) {
24083 {
24084 arg1 = (long)(SWIG_As_long(obj0));
24085 if (SWIG_arg_fail(1)) SWIG_fail;
24086 }
24087 }
24088 if (obj1) {
24089 {
24090 arg2 = (long)(SWIG_As_long(obj1));
24091 if (SWIG_arg_fail(2)) SWIG_fail;
24092 }
24093 }
24094 if (obj2) {
24095 {
24096 arg3 = (long)(SWIG_As_long(obj2));
24097 if (SWIG_arg_fail(3)) SWIG_fail;
24098 }
24099 }
24100 if (obj3) {
24101 {
24102 arg4 = (long)(SWIG_As_long(obj3));
24103 if (SWIG_arg_fail(4)) SWIG_fail;
24104 }
24105 }
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24109
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj;
24122 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24123 PyObject * obj0 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 delete arg1;
24134
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 Py_INCREF(Py_None); resultobj = Py_None;
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj;
24147 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24148 wxTimeSpan *arg2 = 0 ;
24149 wxTimeSpan *result;
24150 PyObject * obj0 = 0 ;
24151 PyObject * obj1 = 0 ;
24152 char *kwnames[] = {
24153 (char *) "self",(char *) "diff", NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24158 if (SWIG_arg_fail(1)) SWIG_fail;
24159 {
24160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24161 if (SWIG_arg_fail(2)) SWIG_fail;
24162 if (arg2 == NULL) {
24163 SWIG_null_ref("wxTimeSpan");
24164 }
24165 if (SWIG_arg_fail(2)) SWIG_fail;
24166 }
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 {
24170 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24171 result = (wxTimeSpan *) &_result_ref;
24172 }
24173
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj;
24186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24187 wxTimeSpan *arg2 = 0 ;
24188 wxTimeSpan *result;
24189 PyObject * obj0 = 0 ;
24190 PyObject * obj1 = 0 ;
24191 char *kwnames[] = {
24192 (char *) "self",(char *) "diff", NULL
24193 };
24194
24195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24197 if (SWIG_arg_fail(1)) SWIG_fail;
24198 {
24199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24200 if (SWIG_arg_fail(2)) SWIG_fail;
24201 if (arg2 == NULL) {
24202 SWIG_null_ref("wxTimeSpan");
24203 }
24204 if (SWIG_arg_fail(2)) SWIG_fail;
24205 }
24206 {
24207 PyThreadState* __tstate = wxPyBeginAllowThreads();
24208 {
24209 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24210 result = (wxTimeSpan *) &_result_ref;
24211 }
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24226 int arg2 ;
24227 wxTimeSpan *result;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 char *kwnames[] = {
24231 (char *) "self",(char *) "n", NULL
24232 };
24233
24234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24236 if (SWIG_arg_fail(1)) SWIG_fail;
24237 {
24238 arg2 = (int)(SWIG_As_int(obj1));
24239 if (SWIG_arg_fail(2)) SWIG_fail;
24240 }
24241 {
24242 PyThreadState* __tstate = wxPyBeginAllowThreads();
24243 {
24244 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24245 result = (wxTimeSpan *) &_result_ref;
24246 }
24247
24248 wxPyEndAllowThreads(__tstate);
24249 if (PyErr_Occurred()) SWIG_fail;
24250 }
24251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24252 return resultobj;
24253 fail:
24254 return NULL;
24255 }
24256
24257
24258 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24259 PyObject *resultobj;
24260 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24261 wxTimeSpan *result;
24262 PyObject * obj0 = 0 ;
24263 char *kwnames[] = {
24264 (char *) "self", NULL
24265 };
24266
24267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24269 if (SWIG_arg_fail(1)) SWIG_fail;
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 {
24273 wxTimeSpan &_result_ref = (arg1)->Neg();
24274 result = (wxTimeSpan *) &_result_ref;
24275 }
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24288 PyObject *resultobj;
24289 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24290 wxTimeSpan result;
24291 PyObject * obj0 = 0 ;
24292 char *kwnames[] = {
24293 (char *) "self", NULL
24294 };
24295
24296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24298 if (SWIG_arg_fail(1)) SWIG_fail;
24299 {
24300 PyThreadState* __tstate = wxPyBeginAllowThreads();
24301 result = ((wxTimeSpan const *)arg1)->Abs();
24302
24303 wxPyEndAllowThreads(__tstate);
24304 if (PyErr_Occurred()) SWIG_fail;
24305 }
24306 {
24307 wxTimeSpan * resultptr;
24308 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24309 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24310 }
24311 return resultobj;
24312 fail:
24313 return NULL;
24314 }
24315
24316
24317 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24318 PyObject *resultobj;
24319 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24320 wxTimeSpan *arg2 = 0 ;
24321 wxTimeSpan *result;
24322 PyObject * obj0 = 0 ;
24323 PyObject * obj1 = 0 ;
24324 char *kwnames[] = {
24325 (char *) "self",(char *) "diff", NULL
24326 };
24327
24328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24330 if (SWIG_arg_fail(1)) SWIG_fail;
24331 {
24332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24333 if (SWIG_arg_fail(2)) SWIG_fail;
24334 if (arg2 == NULL) {
24335 SWIG_null_ref("wxTimeSpan");
24336 }
24337 if (SWIG_arg_fail(2)) SWIG_fail;
24338 }
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 {
24342 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24343 result = (wxTimeSpan *) &_result_ref;
24344 }
24345
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24357 PyObject *resultobj;
24358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24359 wxTimeSpan *arg2 = 0 ;
24360 wxTimeSpan *result;
24361 PyObject * obj0 = 0 ;
24362 PyObject * obj1 = 0 ;
24363 char *kwnames[] = {
24364 (char *) "self",(char *) "diff", NULL
24365 };
24366
24367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24369 if (SWIG_arg_fail(1)) SWIG_fail;
24370 {
24371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24372 if (SWIG_arg_fail(2)) SWIG_fail;
24373 if (arg2 == NULL) {
24374 SWIG_null_ref("wxTimeSpan");
24375 }
24376 if (SWIG_arg_fail(2)) SWIG_fail;
24377 }
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 {
24381 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24382 result = (wxTimeSpan *) &_result_ref;
24383 }
24384
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24396 PyObject *resultobj;
24397 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24398 int arg2 ;
24399 wxTimeSpan *result;
24400 PyObject * obj0 = 0 ;
24401 PyObject * obj1 = 0 ;
24402 char *kwnames[] = {
24403 (char *) "self",(char *) "n", NULL
24404 };
24405
24406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24408 if (SWIG_arg_fail(1)) SWIG_fail;
24409 {
24410 arg2 = (int)(SWIG_As_int(obj1));
24411 if (SWIG_arg_fail(2)) SWIG_fail;
24412 }
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 {
24416 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24417 result = (wxTimeSpan *) &_result_ref;
24418 }
24419
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24433 wxTimeSpan *result;
24434 PyObject * obj0 = 0 ;
24435 char *kwnames[] = {
24436 (char *) "self", NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24441 if (SWIG_arg_fail(1)) SWIG_fail;
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 {
24445 wxTimeSpan &_result_ref = (arg1)->operator -();
24446 result = (wxTimeSpan *) &_result_ref;
24447 }
24448
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24460 PyObject *resultobj;
24461 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24462 wxTimeSpan *arg2 = 0 ;
24463 wxTimeSpan result;
24464 PyObject * obj0 = 0 ;
24465 PyObject * obj1 = 0 ;
24466 char *kwnames[] = {
24467 (char *) "self",(char *) "other", NULL
24468 };
24469
24470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24472 if (SWIG_arg_fail(1)) SWIG_fail;
24473 {
24474 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24475 if (SWIG_arg_fail(2)) SWIG_fail;
24476 if (arg2 == NULL) {
24477 SWIG_null_ref("wxTimeSpan");
24478 }
24479 if (SWIG_arg_fail(2)) SWIG_fail;
24480 }
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 {
24489 wxTimeSpan * resultptr;
24490 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24492 }
24493 return resultobj;
24494 fail:
24495 return NULL;
24496 }
24497
24498
24499 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj;
24501 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24502 wxTimeSpan *arg2 = 0 ;
24503 wxTimeSpan result;
24504 PyObject * obj0 = 0 ;
24505 PyObject * obj1 = 0 ;
24506 char *kwnames[] = {
24507 (char *) "self",(char *) "other", NULL
24508 };
24509
24510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24512 if (SWIG_arg_fail(1)) SWIG_fail;
24513 {
24514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(2)) SWIG_fail;
24516 if (arg2 == NULL) {
24517 SWIG_null_ref("wxTimeSpan");
24518 }
24519 if (SWIG_arg_fail(2)) SWIG_fail;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 {
24529 wxTimeSpan * resultptr;
24530 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24542 int arg2 ;
24543 wxTimeSpan result;
24544 PyObject * obj0 = 0 ;
24545 PyObject * obj1 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self",(char *) "n", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 arg2 = (int)(SWIG_As_int(obj1));
24555 if (SWIG_arg_fail(2)) SWIG_fail;
24556 }
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = wxTimeSpan___mul__(arg1,arg2);
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 {
24565 wxTimeSpan * resultptr;
24566 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj;
24577 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24578 int arg2 ;
24579 wxTimeSpan result;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "n", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 {
24590 arg2 = (int)(SWIG_As_int(obj1));
24591 if (SWIG_arg_fail(2)) SWIG_fail;
24592 }
24593 {
24594 PyThreadState* __tstate = wxPyBeginAllowThreads();
24595 result = wxTimeSpan___rmul__(arg1,arg2);
24596
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 {
24601 wxTimeSpan * resultptr;
24602 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24604 }
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24612 PyObject *resultobj;
24613 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24614 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24615 bool result;
24616 PyObject * obj0 = 0 ;
24617 PyObject * obj1 = 0 ;
24618 char *kwnames[] = {
24619 (char *) "self",(char *) "other", NULL
24620 };
24621
24622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24624 if (SWIG_arg_fail(1)) SWIG_fail;
24625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24626 if (SWIG_arg_fail(2)) SWIG_fail;
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24630
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 {
24635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24636 }
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24644 PyObject *resultobj;
24645 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24646 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24647 bool result;
24648 PyObject * obj0 = 0 ;
24649 PyObject * obj1 = 0 ;
24650 char *kwnames[] = {
24651 (char *) "self",(char *) "other", NULL
24652 };
24653
24654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24656 if (SWIG_arg_fail(1)) SWIG_fail;
24657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24658 if (SWIG_arg_fail(2)) SWIG_fail;
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24662
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 {
24667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24668 }
24669 return resultobj;
24670 fail:
24671 return NULL;
24672 }
24673
24674
24675 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj;
24677 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24678 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24679 bool result;
24680 PyObject * obj0 = 0 ;
24681 PyObject * obj1 = 0 ;
24682 char *kwnames[] = {
24683 (char *) "self",(char *) "other", NULL
24684 };
24685
24686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24688 if (SWIG_arg_fail(1)) SWIG_fail;
24689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24690 if (SWIG_arg_fail(2)) SWIG_fail;
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24694
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 {
24699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24700 }
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24708 PyObject *resultobj;
24709 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24710 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24711 bool result;
24712 PyObject * obj0 = 0 ;
24713 PyObject * obj1 = 0 ;
24714 char *kwnames[] = {
24715 (char *) "self",(char *) "other", NULL
24716 };
24717
24718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24720 if (SWIG_arg_fail(1)) SWIG_fail;
24721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24722 if (SWIG_arg_fail(2)) SWIG_fail;
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24726
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24732 }
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj;
24741 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24742 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24743 bool result;
24744 PyObject * obj0 = 0 ;
24745 PyObject * obj1 = 0 ;
24746 char *kwnames[] = {
24747 (char *) "self",(char *) "other", NULL
24748 };
24749
24750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24752 if (SWIG_arg_fail(1)) SWIG_fail;
24753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24754 if (SWIG_arg_fail(2)) SWIG_fail;
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24758
24759 wxPyEndAllowThreads(__tstate);
24760 if (PyErr_Occurred()) SWIG_fail;
24761 }
24762 {
24763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24764 }
24765 return resultobj;
24766 fail:
24767 return NULL;
24768 }
24769
24770
24771 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj;
24773 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24774 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24775 bool result;
24776 PyObject * obj0 = 0 ;
24777 PyObject * obj1 = 0 ;
24778 char *kwnames[] = {
24779 (char *) "self",(char *) "other", NULL
24780 };
24781
24782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24784 if (SWIG_arg_fail(1)) SWIG_fail;
24785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(2)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24806 bool result;
24807 PyObject * obj0 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj;
24833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24834 bool result;
24835 PyObject * obj0 = 0 ;
24836 char *kwnames[] = {
24837 (char *) "self", NULL
24838 };
24839
24840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24842 if (SWIG_arg_fail(1)) SWIG_fail;
24843 {
24844 PyThreadState* __tstate = wxPyBeginAllowThreads();
24845 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24846
24847 wxPyEndAllowThreads(__tstate);
24848 if (PyErr_Occurred()) SWIG_fail;
24849 }
24850 {
24851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24852 }
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24860 PyObject *resultobj;
24861 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24862 bool result;
24863 PyObject * obj0 = 0 ;
24864 char *kwnames[] = {
24865 (char *) "self", NULL
24866 };
24867
24868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24870 if (SWIG_arg_fail(1)) SWIG_fail;
24871 {
24872 PyThreadState* __tstate = wxPyBeginAllowThreads();
24873 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24874
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24888 PyObject *resultobj;
24889 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24890 wxTimeSpan *arg2 = 0 ;
24891 bool result;
24892 PyObject * obj0 = 0 ;
24893 PyObject * obj1 = 0 ;
24894 char *kwnames[] = {
24895 (char *) "self",(char *) "ts", NULL
24896 };
24897
24898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24900 if (SWIG_arg_fail(1)) SWIG_fail;
24901 {
24902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(2)) SWIG_fail;
24904 if (arg2 == NULL) {
24905 SWIG_null_ref("wxTimeSpan");
24906 }
24907 if (SWIG_arg_fail(2)) SWIG_fail;
24908 }
24909 {
24910 PyThreadState* __tstate = wxPyBeginAllowThreads();
24911 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24912
24913 wxPyEndAllowThreads(__tstate);
24914 if (PyErr_Occurred()) SWIG_fail;
24915 }
24916 {
24917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24918 }
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24926 PyObject *resultobj;
24927 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24928 wxTimeSpan *arg2 = 0 ;
24929 bool result;
24930 PyObject * obj0 = 0 ;
24931 PyObject * obj1 = 0 ;
24932 char *kwnames[] = {
24933 (char *) "self",(char *) "ts", NULL
24934 };
24935
24936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24938 if (SWIG_arg_fail(1)) SWIG_fail;
24939 {
24940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24941 if (SWIG_arg_fail(2)) SWIG_fail;
24942 if (arg2 == NULL) {
24943 SWIG_null_ref("wxTimeSpan");
24944 }
24945 if (SWIG_arg_fail(2)) SWIG_fail;
24946 }
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24950
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 {
24955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24956 }
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj;
24965 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24966 wxTimeSpan *arg2 = 0 ;
24967 bool result;
24968 PyObject * obj0 = 0 ;
24969 PyObject * obj1 = 0 ;
24970 char *kwnames[] = {
24971 (char *) "self",(char *) "t", NULL
24972 };
24973
24974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(1)) SWIG_fail;
24977 {
24978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(2)) SWIG_fail;
24980 if (arg2 == NULL) {
24981 SWIG_null_ref("wxTimeSpan");
24982 }
24983 if (SWIG_arg_fail(2)) SWIG_fail;
24984 }
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj;
25003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25004 int result;
25005 PyObject * obj0 = 0 ;
25006 char *kwnames[] = {
25007 (char *) "self", NULL
25008 };
25009
25010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25012 if (SWIG_arg_fail(1)) SWIG_fail;
25013 {
25014 PyThreadState* __tstate = wxPyBeginAllowThreads();
25015 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25016
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = SWIG_From_int((int)(result));
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj;
25031 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25032 int result;
25033 PyObject * obj0 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25044
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = SWIG_From_int((int)(result));
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj;
25059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25060 int result;
25061 PyObject * obj0 = 0 ;
25062 char *kwnames[] = {
25063 (char *) "self", NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25068 if (SWIG_arg_fail(1)) SWIG_fail;
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25072
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 resultobj = SWIG_From_int((int)(result));
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25088 int result;
25089 PyObject * obj0 = 0 ;
25090 char *kwnames[] = {
25091 (char *) "self", NULL
25092 };
25093
25094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25096 if (SWIG_arg_fail(1)) SWIG_fail;
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25100
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 {
25105 resultobj = SWIG_From_int((int)(result));
25106 }
25107 return resultobj;
25108 fail:
25109 return NULL;
25110 }
25111
25112
25113 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25114 PyObject *resultobj;
25115 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25116 wxLongLong result;
25117 PyObject * obj0 = 0 ;
25118 char *kwnames[] = {
25119 (char *) "self", NULL
25120 };
25121
25122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25124 if (SWIG_arg_fail(1)) SWIG_fail;
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25128
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 {
25133 PyObject *hi, *lo, *shifter, *shifted;
25134 hi = PyLong_FromLong( (&result)->GetHi() );
25135 lo = PyLong_FromLong( (&result)->GetLo() );
25136 shifter = PyLong_FromLong(32);
25137 shifted = PyNumber_Lshift(hi, shifter);
25138 resultobj = PyNumber_Or(shifted, lo);
25139 Py_DECREF(hi);
25140 Py_DECREF(lo);
25141 Py_DECREF(shifter);
25142 Py_DECREF(shifted);
25143 }
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25153 wxLongLong result;
25154 PyObject * obj0 = 0 ;
25155 char *kwnames[] = {
25156 (char *) "self", NULL
25157 };
25158
25159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25161 if (SWIG_arg_fail(1)) SWIG_fail;
25162 {
25163 PyThreadState* __tstate = wxPyBeginAllowThreads();
25164 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25165
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 {
25170 PyObject *hi, *lo, *shifter, *shifted;
25171 hi = PyLong_FromLong( (&result)->GetHi() );
25172 lo = PyLong_FromLong( (&result)->GetLo() );
25173 shifter = PyLong_FromLong(32);
25174 shifted = PyNumber_Lshift(hi, shifter);
25175 resultobj = PyNumber_Or(shifted, lo);
25176 Py_DECREF(hi);
25177 Py_DECREF(lo);
25178 Py_DECREF(shifter);
25179 Py_DECREF(shifted);
25180 }
25181 return resultobj;
25182 fail:
25183 return NULL;
25184 }
25185
25186
25187 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25188 PyObject *resultobj;
25189 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25190 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25191 wxString *arg2 = (wxString *) &arg2_defvalue ;
25192 wxString result;
25193 bool temp2 = false ;
25194 PyObject * obj0 = 0 ;
25195 PyObject * obj1 = 0 ;
25196 char *kwnames[] = {
25197 (char *) "self",(char *) "format", NULL
25198 };
25199
25200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25202 if (SWIG_arg_fail(1)) SWIG_fail;
25203 if (obj1) {
25204 {
25205 arg2 = wxString_in_helper(obj1);
25206 if (arg2 == NULL) SWIG_fail;
25207 temp2 = true;
25208 }
25209 }
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 #if wxUSE_UNICODE
25219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25220 #else
25221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25222 #endif
25223 }
25224 {
25225 if (temp2)
25226 delete arg2;
25227 }
25228 return resultobj;
25229 fail:
25230 {
25231 if (temp2)
25232 delete arg2;
25233 }
25234 return NULL;
25235 }
25236
25237
25238 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25239 PyObject *obj;
25240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25241 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25242 Py_INCREF(obj);
25243 return Py_BuildValue((char *)"");
25244 }
25245 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25246 PyObject *resultobj;
25247 int arg1 = (int) 0 ;
25248 int arg2 = (int) 0 ;
25249 int arg3 = (int) 0 ;
25250 int arg4 = (int) 0 ;
25251 wxDateSpan *result;
25252 PyObject * obj0 = 0 ;
25253 PyObject * obj1 = 0 ;
25254 PyObject * obj2 = 0 ;
25255 PyObject * obj3 = 0 ;
25256 char *kwnames[] = {
25257 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25258 };
25259
25260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25261 if (obj0) {
25262 {
25263 arg1 = (int)(SWIG_As_int(obj0));
25264 if (SWIG_arg_fail(1)) SWIG_fail;
25265 }
25266 }
25267 if (obj1) {
25268 {
25269 arg2 = (int)(SWIG_As_int(obj1));
25270 if (SWIG_arg_fail(2)) SWIG_fail;
25271 }
25272 }
25273 if (obj2) {
25274 {
25275 arg3 = (int)(SWIG_As_int(obj2));
25276 if (SWIG_arg_fail(3)) SWIG_fail;
25277 }
25278 }
25279 if (obj3) {
25280 {
25281 arg4 = (int)(SWIG_As_int(obj3));
25282 if (SWIG_arg_fail(4)) SWIG_fail;
25283 }
25284 }
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25288
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj;
25301 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25302 PyObject * obj0 = 0 ;
25303 char *kwnames[] = {
25304 (char *) "self", NULL
25305 };
25306
25307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25309 if (SWIG_arg_fail(1)) SWIG_fail;
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 delete arg1;
25313
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 Py_INCREF(Py_None); resultobj = Py_None;
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25325 PyObject *resultobj;
25326 int arg1 ;
25327 wxDateSpan result;
25328 PyObject * obj0 = 0 ;
25329 char *kwnames[] = {
25330 (char *) "days", NULL
25331 };
25332
25333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25334 {
25335 arg1 = (int)(SWIG_As_int(obj0));
25336 if (SWIG_arg_fail(1)) SWIG_fail;
25337 }
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = wxDateSpan::Days(arg1);
25341
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 {
25346 wxDateSpan * resultptr;
25347 resultptr = new wxDateSpan((wxDateSpan &)(result));
25348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25349 }
25350 return resultobj;
25351 fail:
25352 return NULL;
25353 }
25354
25355
25356 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25357 PyObject *resultobj;
25358 wxDateSpan result;
25359 char *kwnames[] = {
25360 NULL
25361 };
25362
25363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = wxDateSpan::Day();
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 {
25372 wxDateSpan * resultptr;
25373 resultptr = new wxDateSpan((wxDateSpan &)(result));
25374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25375 }
25376 return resultobj;
25377 fail:
25378 return NULL;
25379 }
25380
25381
25382 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj;
25384 int arg1 ;
25385 wxDateSpan result;
25386 PyObject * obj0 = 0 ;
25387 char *kwnames[] = {
25388 (char *) "weeks", NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25392 {
25393 arg1 = (int)(SWIG_As_int(obj0));
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 }
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 result = wxDateSpan::Weeks(arg1);
25399
25400 wxPyEndAllowThreads(__tstate);
25401 if (PyErr_Occurred()) SWIG_fail;
25402 }
25403 {
25404 wxDateSpan * resultptr;
25405 resultptr = new wxDateSpan((wxDateSpan &)(result));
25406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25407 }
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25415 PyObject *resultobj;
25416 wxDateSpan result;
25417 char *kwnames[] = {
25418 NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 result = wxDateSpan::Week();
25425
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 {
25430 wxDateSpan * resultptr;
25431 resultptr = new wxDateSpan((wxDateSpan &)(result));
25432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25433 }
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25441 PyObject *resultobj;
25442 int arg1 ;
25443 wxDateSpan result;
25444 PyObject * obj0 = 0 ;
25445 char *kwnames[] = {
25446 (char *) "mon", NULL
25447 };
25448
25449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25450 {
25451 arg1 = (int)(SWIG_As_int(obj0));
25452 if (SWIG_arg_fail(1)) SWIG_fail;
25453 }
25454 {
25455 PyThreadState* __tstate = wxPyBeginAllowThreads();
25456 result = wxDateSpan::Months(arg1);
25457
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 {
25462 wxDateSpan * resultptr;
25463 resultptr = new wxDateSpan((wxDateSpan &)(result));
25464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25465 }
25466 return resultobj;
25467 fail:
25468 return NULL;
25469 }
25470
25471
25472 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25473 PyObject *resultobj;
25474 wxDateSpan result;
25475 char *kwnames[] = {
25476 NULL
25477 };
25478
25479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 result = wxDateSpan::Month();
25483
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 {
25488 wxDateSpan * resultptr;
25489 resultptr = new wxDateSpan((wxDateSpan &)(result));
25490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25491 }
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj;
25500 int arg1 ;
25501 wxDateSpan result;
25502 PyObject * obj0 = 0 ;
25503 char *kwnames[] = {
25504 (char *) "years", NULL
25505 };
25506
25507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25508 {
25509 arg1 = (int)(SWIG_As_int(obj0));
25510 if (SWIG_arg_fail(1)) SWIG_fail;
25511 }
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 result = wxDateSpan::Years(arg1);
25515
25516 wxPyEndAllowThreads(__tstate);
25517 if (PyErr_Occurred()) SWIG_fail;
25518 }
25519 {
25520 wxDateSpan * resultptr;
25521 resultptr = new wxDateSpan((wxDateSpan &)(result));
25522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25523 }
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25531 PyObject *resultobj;
25532 wxDateSpan result;
25533 char *kwnames[] = {
25534 NULL
25535 };
25536
25537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25538 {
25539 PyThreadState* __tstate = wxPyBeginAllowThreads();
25540 result = wxDateSpan::Year();
25541
25542 wxPyEndAllowThreads(__tstate);
25543 if (PyErr_Occurred()) SWIG_fail;
25544 }
25545 {
25546 wxDateSpan * resultptr;
25547 resultptr = new wxDateSpan((wxDateSpan &)(result));
25548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25549 }
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj;
25558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25559 int arg2 ;
25560 wxDateSpan *result;
25561 PyObject * obj0 = 0 ;
25562 PyObject * obj1 = 0 ;
25563 char *kwnames[] = {
25564 (char *) "self",(char *) "n", NULL
25565 };
25566
25567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25569 if (SWIG_arg_fail(1)) SWIG_fail;
25570 {
25571 arg2 = (int)(SWIG_As_int(obj1));
25572 if (SWIG_arg_fail(2)) SWIG_fail;
25573 }
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 {
25577 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25578 result = (wxDateSpan *) &_result_ref;
25579 }
25580
25581 wxPyEndAllowThreads(__tstate);
25582 if (PyErr_Occurred()) SWIG_fail;
25583 }
25584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj;
25593 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25594 int arg2 ;
25595 wxDateSpan *result;
25596 PyObject * obj0 = 0 ;
25597 PyObject * obj1 = 0 ;
25598 char *kwnames[] = {
25599 (char *) "self",(char *) "n", NULL
25600 };
25601
25602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25604 if (SWIG_arg_fail(1)) SWIG_fail;
25605 {
25606 arg2 = (int)(SWIG_As_int(obj1));
25607 if (SWIG_arg_fail(2)) SWIG_fail;
25608 }
25609 {
25610 PyThreadState* __tstate = wxPyBeginAllowThreads();
25611 {
25612 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25613 result = (wxDateSpan *) &_result_ref;
25614 }
25615
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25627 PyObject *resultobj;
25628 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25629 int arg2 ;
25630 wxDateSpan *result;
25631 PyObject * obj0 = 0 ;
25632 PyObject * obj1 = 0 ;
25633 char *kwnames[] = {
25634 (char *) "self",(char *) "n", NULL
25635 };
25636
25637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25639 if (SWIG_arg_fail(1)) SWIG_fail;
25640 {
25641 arg2 = (int)(SWIG_As_int(obj1));
25642 if (SWIG_arg_fail(2)) SWIG_fail;
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 {
25647 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25648 result = (wxDateSpan *) &_result_ref;
25649 }
25650
25651 wxPyEndAllowThreads(__tstate);
25652 if (PyErr_Occurred()) SWIG_fail;
25653 }
25654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj;
25663 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25664 int arg2 ;
25665 wxDateSpan *result;
25666 PyObject * obj0 = 0 ;
25667 PyObject * obj1 = 0 ;
25668 char *kwnames[] = {
25669 (char *) "self",(char *) "n", NULL
25670 };
25671
25672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25674 if (SWIG_arg_fail(1)) SWIG_fail;
25675 {
25676 arg2 = (int)(SWIG_As_int(obj1));
25677 if (SWIG_arg_fail(2)) SWIG_fail;
25678 }
25679 {
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 {
25682 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25683 result = (wxDateSpan *) &_result_ref;
25684 }
25685
25686 wxPyEndAllowThreads(__tstate);
25687 if (PyErr_Occurred()) SWIG_fail;
25688 }
25689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25699 int result;
25700 PyObject * obj0 = 0 ;
25701 char *kwnames[] = {
25702 (char *) "self", NULL
25703 };
25704
25705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(1)) SWIG_fail;
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (int)((wxDateSpan const *)arg1)->GetYears();
25711
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 {
25716 resultobj = SWIG_From_int((int)(result));
25717 }
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj;
25726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25727 int result;
25728 PyObject * obj0 = 0 ;
25729 char *kwnames[] = {
25730 (char *) "self", NULL
25731 };
25732
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(1)) SWIG_fail;
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = SWIG_From_int((int)(result));
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25755 int result;
25756 PyObject * obj0 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25767
25768 wxPyEndAllowThreads(__tstate);
25769 if (PyErr_Occurred()) SWIG_fail;
25770 }
25771 {
25772 resultobj = SWIG_From_int((int)(result));
25773 }
25774 return resultobj;
25775 fail:
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25783 int result;
25784 PyObject * obj0 = 0 ;
25785 char *kwnames[] = {
25786 (char *) "self", NULL
25787 };
25788
25789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25791 if (SWIG_arg_fail(1)) SWIG_fail;
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 result = (int)((wxDateSpan const *)arg1)->GetDays();
25795
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 {
25800 resultobj = SWIG_From_int((int)(result));
25801 }
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj;
25810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25811 int result;
25812 PyObject * obj0 = 0 ;
25813 char *kwnames[] = {
25814 (char *) "self", NULL
25815 };
25816
25817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25819 if (SWIG_arg_fail(1)) SWIG_fail;
25820 {
25821 PyThreadState* __tstate = wxPyBeginAllowThreads();
25822 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25823
25824 wxPyEndAllowThreads(__tstate);
25825 if (PyErr_Occurred()) SWIG_fail;
25826 }
25827 {
25828 resultobj = SWIG_From_int((int)(result));
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj;
25838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25839 wxDateSpan *arg2 = 0 ;
25840 wxDateSpan *result;
25841 PyObject * obj0 = 0 ;
25842 PyObject * obj1 = 0 ;
25843 char *kwnames[] = {
25844 (char *) "self",(char *) "other", NULL
25845 };
25846
25847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25849 if (SWIG_arg_fail(1)) SWIG_fail;
25850 {
25851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25852 if (SWIG_arg_fail(2)) SWIG_fail;
25853 if (arg2 == NULL) {
25854 SWIG_null_ref("wxDateSpan");
25855 }
25856 if (SWIG_arg_fail(2)) SWIG_fail;
25857 }
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 {
25861 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25862 result = (wxDateSpan *) &_result_ref;
25863 }
25864
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj;
25877 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25878 wxDateSpan *arg2 = 0 ;
25879 wxDateSpan *result;
25880 PyObject * obj0 = 0 ;
25881 PyObject * obj1 = 0 ;
25882 char *kwnames[] = {
25883 (char *) "self",(char *) "other", NULL
25884 };
25885
25886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25888 if (SWIG_arg_fail(1)) SWIG_fail;
25889 {
25890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(2)) SWIG_fail;
25892 if (arg2 == NULL) {
25893 SWIG_null_ref("wxDateSpan");
25894 }
25895 if (SWIG_arg_fail(2)) SWIG_fail;
25896 }
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 {
25900 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25901 result = (wxDateSpan *) &_result_ref;
25902 }
25903
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj;
25916 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25917 wxDateSpan *result;
25918 PyObject * obj0 = 0 ;
25919 char *kwnames[] = {
25920 (char *) "self", NULL
25921 };
25922
25923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25925 if (SWIG_arg_fail(1)) SWIG_fail;
25926 {
25927 PyThreadState* __tstate = wxPyBeginAllowThreads();
25928 {
25929 wxDateSpan &_result_ref = (arg1)->Neg();
25930 result = (wxDateSpan *) &_result_ref;
25931 }
25932
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25944 PyObject *resultobj;
25945 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25946 int arg2 ;
25947 wxDateSpan *result;
25948 PyObject * obj0 = 0 ;
25949 PyObject * obj1 = 0 ;
25950 char *kwnames[] = {
25951 (char *) "self",(char *) "factor", NULL
25952 };
25953
25954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25956 if (SWIG_arg_fail(1)) SWIG_fail;
25957 {
25958 arg2 = (int)(SWIG_As_int(obj1));
25959 if (SWIG_arg_fail(2)) SWIG_fail;
25960 }
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 {
25964 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25965 result = (wxDateSpan *) &_result_ref;
25966 }
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25981 wxDateSpan *arg2 = 0 ;
25982 wxDateSpan *result;
25983 PyObject * obj0 = 0 ;
25984 PyObject * obj1 = 0 ;
25985 char *kwnames[] = {
25986 (char *) "self",(char *) "other", NULL
25987 };
25988
25989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25991 if (SWIG_arg_fail(1)) SWIG_fail;
25992 {
25993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25994 if (SWIG_arg_fail(2)) SWIG_fail;
25995 if (arg2 == NULL) {
25996 SWIG_null_ref("wxDateSpan");
25997 }
25998 if (SWIG_arg_fail(2)) SWIG_fail;
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 {
26003 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26004 result = (wxDateSpan *) &_result_ref;
26005 }
26006
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26018 PyObject *resultobj;
26019 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26020 wxDateSpan *arg2 = 0 ;
26021 wxDateSpan *result;
26022 PyObject * obj0 = 0 ;
26023 PyObject * obj1 = 0 ;
26024 char *kwnames[] = {
26025 (char *) "self",(char *) "other", NULL
26026 };
26027
26028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26030 if (SWIG_arg_fail(1)) SWIG_fail;
26031 {
26032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26033 if (SWIG_arg_fail(2)) SWIG_fail;
26034 if (arg2 == NULL) {
26035 SWIG_null_ref("wxDateSpan");
26036 }
26037 if (SWIG_arg_fail(2)) SWIG_fail;
26038 }
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 {
26042 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26043 result = (wxDateSpan *) &_result_ref;
26044 }
26045
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj;
26058 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26059 wxDateSpan *result;
26060 PyObject * obj0 = 0 ;
26061 char *kwnames[] = {
26062 (char *) "self", NULL
26063 };
26064
26065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26067 if (SWIG_arg_fail(1)) SWIG_fail;
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 {
26071 wxDateSpan &_result_ref = (arg1)->operator -();
26072 result = (wxDateSpan *) &_result_ref;
26073 }
26074
26075 wxPyEndAllowThreads(__tstate);
26076 if (PyErr_Occurred()) SWIG_fail;
26077 }
26078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj;
26087 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26088 int arg2 ;
26089 wxDateSpan *result;
26090 PyObject * obj0 = 0 ;
26091 PyObject * obj1 = 0 ;
26092 char *kwnames[] = {
26093 (char *) "self",(char *) "factor", NULL
26094 };
26095
26096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26098 if (SWIG_arg_fail(1)) SWIG_fail;
26099 {
26100 arg2 = (int)(SWIG_As_int(obj1));
26101 if (SWIG_arg_fail(2)) SWIG_fail;
26102 }
26103 {
26104 PyThreadState* __tstate = wxPyBeginAllowThreads();
26105 {
26106 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26107 result = (wxDateSpan *) &_result_ref;
26108 }
26109
26110 wxPyEndAllowThreads(__tstate);
26111 if (PyErr_Occurred()) SWIG_fail;
26112 }
26113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26123 wxDateSpan *arg2 = 0 ;
26124 wxDateSpan result;
26125 PyObject * obj0 = 0 ;
26126 PyObject * obj1 = 0 ;
26127 char *kwnames[] = {
26128 (char *) "self",(char *) "other", NULL
26129 };
26130
26131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26133 if (SWIG_arg_fail(1)) SWIG_fail;
26134 {
26135 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26136 if (SWIG_arg_fail(2)) SWIG_fail;
26137 if (arg2 == NULL) {
26138 SWIG_null_ref("wxDateSpan");
26139 }
26140 if (SWIG_arg_fail(2)) SWIG_fail;
26141 }
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26145
26146 wxPyEndAllowThreads(__tstate);
26147 if (PyErr_Occurred()) SWIG_fail;
26148 }
26149 {
26150 wxDateSpan * resultptr;
26151 resultptr = new wxDateSpan((wxDateSpan &)(result));
26152 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26153 }
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj;
26162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26163 wxDateSpan *arg2 = 0 ;
26164 wxDateSpan result;
26165 PyObject * obj0 = 0 ;
26166 PyObject * obj1 = 0 ;
26167 char *kwnames[] = {
26168 (char *) "self",(char *) "other", NULL
26169 };
26170
26171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26173 if (SWIG_arg_fail(1)) SWIG_fail;
26174 {
26175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26176 if (SWIG_arg_fail(2)) SWIG_fail;
26177 if (arg2 == NULL) {
26178 SWIG_null_ref("wxDateSpan");
26179 }
26180 if (SWIG_arg_fail(2)) SWIG_fail;
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 {
26190 wxDateSpan * resultptr;
26191 resultptr = new wxDateSpan((wxDateSpan &)(result));
26192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26203 int arg2 ;
26204 wxDateSpan result;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char *kwnames[] = {
26208 (char *) "self",(char *) "n", NULL
26209 };
26210
26211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 {
26215 arg2 = (int)(SWIG_As_int(obj1));
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 }
26218 {
26219 PyThreadState* __tstate = wxPyBeginAllowThreads();
26220 result = wxDateSpan___mul__(arg1,arg2);
26221
26222 wxPyEndAllowThreads(__tstate);
26223 if (PyErr_Occurred()) SWIG_fail;
26224 }
26225 {
26226 wxDateSpan * resultptr;
26227 resultptr = new wxDateSpan((wxDateSpan &)(result));
26228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26229 }
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26237 PyObject *resultobj;
26238 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26239 int arg2 ;
26240 wxDateSpan result;
26241 PyObject * obj0 = 0 ;
26242 PyObject * obj1 = 0 ;
26243 char *kwnames[] = {
26244 (char *) "self",(char *) "n", NULL
26245 };
26246
26247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26249 if (SWIG_arg_fail(1)) SWIG_fail;
26250 {
26251 arg2 = (int)(SWIG_As_int(obj1));
26252 if (SWIG_arg_fail(2)) SWIG_fail;
26253 }
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 result = wxDateSpan___rmul__(arg1,arg2);
26257
26258 wxPyEndAllowThreads(__tstate);
26259 if (PyErr_Occurred()) SWIG_fail;
26260 }
26261 {
26262 wxDateSpan * resultptr;
26263 resultptr = new wxDateSpan((wxDateSpan &)(result));
26264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26265 }
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26273 PyObject *resultobj;
26274 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26275 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26276 bool result;
26277 PyObject * obj0 = 0 ;
26278 PyObject * obj1 = 0 ;
26279 char *kwnames[] = {
26280 (char *) "self",(char *) "other", NULL
26281 };
26282
26283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26285 if (SWIG_arg_fail(1)) SWIG_fail;
26286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26287 if (SWIG_arg_fail(2)) SWIG_fail;
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26291
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 {
26296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26297 }
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26305 PyObject *resultobj;
26306 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26307 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26308 bool result;
26309 PyObject * obj0 = 0 ;
26310 PyObject * obj1 = 0 ;
26311 char *kwnames[] = {
26312 (char *) "self",(char *) "other", NULL
26313 };
26314
26315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26317 if (SWIG_arg_fail(1)) SWIG_fail;
26318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26319 if (SWIG_arg_fail(2)) SWIG_fail;
26320 {
26321 PyThreadState* __tstate = wxPyBeginAllowThreads();
26322 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26323
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 {
26328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26329 }
26330 return resultobj;
26331 fail:
26332 return NULL;
26333 }
26334
26335
26336 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26337 PyObject *obj;
26338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26339 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26340 Py_INCREF(obj);
26341 return Py_BuildValue((char *)"");
26342 }
26343 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 long result;
26346 char *kwnames[] = {
26347 NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (long)wxGetLocalTime();
26354
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 {
26359 resultobj = SWIG_From_long((long)(result));
26360 }
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj;
26369 long result;
26370 char *kwnames[] = {
26371 NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26375 {
26376 PyThreadState* __tstate = wxPyBeginAllowThreads();
26377 result = (long)wxGetUTCTime();
26378
26379 wxPyEndAllowThreads(__tstate);
26380 if (PyErr_Occurred()) SWIG_fail;
26381 }
26382 {
26383 resultobj = SWIG_From_long((long)(result));
26384 }
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_GetCurrentTime(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 *)":GetCurrentTime",kwnames)) goto fail;
26399 {
26400 PyThreadState* __tstate = wxPyBeginAllowThreads();
26401 result = (long)wxGetCurrentTime();
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_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 wxLongLong result;
26418 char *kwnames[] = {
26419 NULL
26420 };
26421
26422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 result = wxGetLocalTimeMillis();
26426
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 {
26431 PyObject *hi, *lo, *shifter, *shifted;
26432 hi = PyLong_FromLong( (&result)->GetHi() );
26433 lo = PyLong_FromLong( (&result)->GetLo() );
26434 shifter = PyLong_FromLong(32);
26435 shifted = PyNumber_Lshift(hi, shifter);
26436 resultobj = PyNumber_Or(shifted, lo);
26437 Py_DECREF(hi);
26438 Py_DECREF(lo);
26439 Py_DECREF(shifter);
26440 Py_DECREF(shifted);
26441 }
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 static int _wrap_DefaultDateTime_set(PyObject *) {
26449 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26450 return 1;
26451 }
26452
26453
26454 static PyObject *_wrap_DefaultDateTime_get(void) {
26455 PyObject *pyobj;
26456
26457 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26458 return pyobj;
26459 }
26460
26461
26462 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj;
26464 wxDataFormatId arg1 ;
26465 wxDataFormat *result;
26466 PyObject * obj0 = 0 ;
26467 char *kwnames[] = {
26468 (char *) "type", NULL
26469 };
26470
26471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26472 {
26473 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26474 if (SWIG_arg_fail(1)) SWIG_fail;
26475 }
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26491 PyObject *resultobj;
26492 wxString *arg1 = 0 ;
26493 wxDataFormat *result;
26494 bool temp1 = false ;
26495 PyObject * obj0 = 0 ;
26496 char *kwnames[] = {
26497 (char *) "format", NULL
26498 };
26499
26500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26501 {
26502 arg1 = wxString_in_helper(obj0);
26503 if (arg1 == NULL) SWIG_fail;
26504 temp1 = true;
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26514 {
26515 if (temp1)
26516 delete arg1;
26517 }
26518 return resultobj;
26519 fail:
26520 {
26521 if (temp1)
26522 delete arg1;
26523 }
26524 return NULL;
26525 }
26526
26527
26528 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26529 PyObject *resultobj;
26530 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26531 PyObject * obj0 = 0 ;
26532 char *kwnames[] = {
26533 (char *) "self", NULL
26534 };
26535
26536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26538 if (SWIG_arg_fail(1)) SWIG_fail;
26539 {
26540 PyThreadState* __tstate = wxPyBeginAllowThreads();
26541 delete arg1;
26542
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 Py_INCREF(Py_None); resultobj = Py_None;
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26554 PyObject *resultobj;
26555 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26556 wxDataFormatId arg2 ;
26557 bool result;
26558 PyObject * obj0 = 0 ;
26559 PyObject * obj1 = 0 ;
26560
26561 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26563 if (SWIG_arg_fail(1)) SWIG_fail;
26564 {
26565 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26566 if (SWIG_arg_fail(2)) SWIG_fail;
26567 }
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26571
26572 wxPyEndAllowThreads(__tstate);
26573 if (PyErr_Occurred()) SWIG_fail;
26574 }
26575 {
26576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26577 }
26578 return resultobj;
26579 fail:
26580 return NULL;
26581 }
26582
26583
26584 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26585 PyObject *resultobj;
26586 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26587 wxDataFormatId arg2 ;
26588 bool result;
26589 PyObject * obj0 = 0 ;
26590 PyObject * obj1 = 0 ;
26591
26592 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26594 if (SWIG_arg_fail(1)) SWIG_fail;
26595 {
26596 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26597 if (SWIG_arg_fail(2)) SWIG_fail;
26598 }
26599 {
26600 PyThreadState* __tstate = wxPyBeginAllowThreads();
26601 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26602
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 {
26607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26616 PyObject *resultobj;
26617 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26618 wxDataFormat *arg2 = 0 ;
26619 bool result;
26620 PyObject * obj0 = 0 ;
26621 PyObject * obj1 = 0 ;
26622
26623 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26625 if (SWIG_arg_fail(1)) SWIG_fail;
26626 {
26627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26628 if (SWIG_arg_fail(2)) SWIG_fail;
26629 if (arg2 == NULL) {
26630 SWIG_null_ref("wxDataFormat");
26631 }
26632 if (SWIG_arg_fail(2)) SWIG_fail;
26633 }
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26637
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 {
26642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26643 }
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26651 int argc;
26652 PyObject *argv[3];
26653 int ii;
26654
26655 argc = PyObject_Length(args);
26656 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26657 argv[ii] = PyTuple_GetItem(args,ii);
26658 }
26659 if (argc == 2) {
26660 int _v;
26661 {
26662 void *ptr;
26663 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26664 _v = 0;
26665 PyErr_Clear();
26666 } else {
26667 _v = 1;
26668 }
26669 }
26670 if (_v) {
26671 {
26672 void *ptr = 0;
26673 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26674 _v = 0;
26675 PyErr_Clear();
26676 } else {
26677 _v = (ptr != 0);
26678 }
26679 }
26680 if (_v) {
26681 return _wrap_DataFormat___eq____SWIG_1(self,args);
26682 }
26683 }
26684 }
26685 if (argc == 2) {
26686 int _v;
26687 {
26688 void *ptr;
26689 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26690 _v = 0;
26691 PyErr_Clear();
26692 } else {
26693 _v = 1;
26694 }
26695 }
26696 if (_v) {
26697 _v = SWIG_Check_int(argv[1]);
26698 if (_v) {
26699 return _wrap_DataFormat___eq____SWIG_0(self,args);
26700 }
26701 }
26702 }
26703
26704 Py_INCREF(Py_NotImplemented);
26705 return Py_NotImplemented;
26706 }
26707
26708
26709 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26710 PyObject *resultobj;
26711 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26712 wxDataFormat *arg2 = 0 ;
26713 bool result;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716
26717 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26719 if (SWIG_arg_fail(1)) SWIG_fail;
26720 {
26721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26722 if (SWIG_arg_fail(2)) SWIG_fail;
26723 if (arg2 == NULL) {
26724 SWIG_null_ref("wxDataFormat");
26725 }
26726 if (SWIG_arg_fail(2)) SWIG_fail;
26727 }
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26731
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26745 int argc;
26746 PyObject *argv[3];
26747 int ii;
26748
26749 argc = PyObject_Length(args);
26750 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26751 argv[ii] = PyTuple_GetItem(args,ii);
26752 }
26753 if (argc == 2) {
26754 int _v;
26755 {
26756 void *ptr;
26757 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26758 _v = 0;
26759 PyErr_Clear();
26760 } else {
26761 _v = 1;
26762 }
26763 }
26764 if (_v) {
26765 {
26766 void *ptr = 0;
26767 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26768 _v = 0;
26769 PyErr_Clear();
26770 } else {
26771 _v = (ptr != 0);
26772 }
26773 }
26774 if (_v) {
26775 return _wrap_DataFormat___ne____SWIG_1(self,args);
26776 }
26777 }
26778 }
26779 if (argc == 2) {
26780 int _v;
26781 {
26782 void *ptr;
26783 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26784 _v = 0;
26785 PyErr_Clear();
26786 } else {
26787 _v = 1;
26788 }
26789 }
26790 if (_v) {
26791 _v = SWIG_Check_int(argv[1]);
26792 if (_v) {
26793 return _wrap_DataFormat___ne____SWIG_0(self,args);
26794 }
26795 }
26796 }
26797
26798 Py_INCREF(Py_NotImplemented);
26799 return Py_NotImplemented;
26800 }
26801
26802
26803 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26804 PyObject *resultobj;
26805 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26806 wxDataFormatId arg2 ;
26807 PyObject * obj0 = 0 ;
26808 PyObject * obj1 = 0 ;
26809 char *kwnames[] = {
26810 (char *) "self",(char *) "format", NULL
26811 };
26812
26813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26818 if (SWIG_arg_fail(2)) SWIG_fail;
26819 }
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 (arg1)->SetType((wxDataFormatId )arg2);
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 Py_INCREF(Py_None); resultobj = Py_None;
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26837 wxDataFormatId result;
26838 PyObject * obj0 = 0 ;
26839 char *kwnames[] = {
26840 (char *) "self", NULL
26841 };
26842
26843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26845 if (SWIG_arg_fail(1)) SWIG_fail;
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26849
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 resultobj = SWIG_From_int((result));
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj;
26862 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26863 wxString result;
26864 PyObject * obj0 = 0 ;
26865 char *kwnames[] = {
26866 (char *) "self", NULL
26867 };
26868
26869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26871 if (SWIG_arg_fail(1)) SWIG_fail;
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = ((wxDataFormat const *)arg1)->GetId();
26875
26876 wxPyEndAllowThreads(__tstate);
26877 if (PyErr_Occurred()) SWIG_fail;
26878 }
26879 {
26880 #if wxUSE_UNICODE
26881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26882 #else
26883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26884 #endif
26885 }
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26895 wxString *arg2 = 0 ;
26896 bool temp2 = false ;
26897 PyObject * obj0 = 0 ;
26898 PyObject * obj1 = 0 ;
26899 char *kwnames[] = {
26900 (char *) "self",(char *) "format", NULL
26901 };
26902
26903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26905 if (SWIG_arg_fail(1)) SWIG_fail;
26906 {
26907 arg2 = wxString_in_helper(obj1);
26908 if (arg2 == NULL) SWIG_fail;
26909 temp2 = true;
26910 }
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 (arg1)->SetId((wxString const &)*arg2);
26914
26915 wxPyEndAllowThreads(__tstate);
26916 if (PyErr_Occurred()) SWIG_fail;
26917 }
26918 Py_INCREF(Py_None); resultobj = Py_None;
26919 {
26920 if (temp2)
26921 delete arg2;
26922 }
26923 return resultobj;
26924 fail:
26925 {
26926 if (temp2)
26927 delete arg2;
26928 }
26929 return NULL;
26930 }
26931
26932
26933 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26934 PyObject *obj;
26935 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26936 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26937 Py_INCREF(obj);
26938 return Py_BuildValue((char *)"");
26939 }
26940 static int _wrap_FormatInvalid_set(PyObject *) {
26941 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26942 return 1;
26943 }
26944
26945
26946 static PyObject *_wrap_FormatInvalid_get(void) {
26947 PyObject *pyobj;
26948
26949 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26950 return pyobj;
26951 }
26952
26953
26954 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26955 PyObject *resultobj;
26956 wxDataObject *arg1 = (wxDataObject *) 0 ;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 delete arg1;
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 Py_INCREF(Py_None); resultobj = Py_None;
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26980 PyObject *resultobj;
26981 wxDataObject *arg1 = (wxDataObject *) 0 ;
26982 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26983 SwigValueWrapper<wxDataFormat > result;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 char *kwnames[] = {
26987 (char *) "self",(char *) "dir", NULL
26988 };
26989
26990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26992 if (SWIG_arg_fail(1)) SWIG_fail;
26993 if (obj1) {
26994 {
26995 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26996 if (SWIG_arg_fail(2)) SWIG_fail;
26997 }
26998 }
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27002
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 wxDataFormat * resultptr;
27008 resultptr = new wxDataFormat((wxDataFormat &)(result));
27009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj;
27019 wxDataObject *arg1 = (wxDataObject *) 0 ;
27020 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27021 size_t result;
27022 PyObject * obj0 = 0 ;
27023 PyObject * obj1 = 0 ;
27024 char *kwnames[] = {
27025 (char *) "self",(char *) "dir", NULL
27026 };
27027
27028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27030 if (SWIG_arg_fail(1)) SWIG_fail;
27031 if (obj1) {
27032 {
27033 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27034 if (SWIG_arg_fail(2)) SWIG_fail;
27035 }
27036 }
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27040
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 {
27045 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27046 }
27047 return resultobj;
27048 fail:
27049 return NULL;
27050 }
27051
27052
27053 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj;
27055 wxDataObject *arg1 = (wxDataObject *) 0 ;
27056 wxDataFormat *arg2 = 0 ;
27057 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27058 bool result;
27059 PyObject * obj0 = 0 ;
27060 PyObject * obj1 = 0 ;
27061 PyObject * obj2 = 0 ;
27062 char *kwnames[] = {
27063 (char *) "self",(char *) "format",(char *) "dir", NULL
27064 };
27065
27066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27068 if (SWIG_arg_fail(1)) SWIG_fail;
27069 {
27070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(2)) SWIG_fail;
27072 if (arg2 == NULL) {
27073 SWIG_null_ref("wxDataFormat");
27074 }
27075 if (SWIG_arg_fail(2)) SWIG_fail;
27076 }
27077 if (obj2) {
27078 {
27079 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27080 if (SWIG_arg_fail(3)) SWIG_fail;
27081 }
27082 }
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27086
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 {
27091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27092 }
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj;
27101 wxDataObject *arg1 = (wxDataObject *) 0 ;
27102 wxDataFormat *arg2 = 0 ;
27103 size_t result;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 char *kwnames[] = {
27107 (char *) "self",(char *) "format", NULL
27108 };
27109
27110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27112 if (SWIG_arg_fail(1)) SWIG_fail;
27113 {
27114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(2)) SWIG_fail;
27116 if (arg2 == NULL) {
27117 SWIG_null_ref("wxDataFormat");
27118 }
27119 if (SWIG_arg_fail(2)) SWIG_fail;
27120 }
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27124
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 {
27129 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj;
27139 wxDataObject *arg1 = (wxDataObject *) 0 ;
27140 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27141 PyObject *result;
27142 PyObject * obj0 = 0 ;
27143 PyObject * obj1 = 0 ;
27144 char *kwnames[] = {
27145 (char *) "self",(char *) "dir", NULL
27146 };
27147
27148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(1)) SWIG_fail;
27151 if (obj1) {
27152 {
27153 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 }
27156 }
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 resultobj = result;
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj;
27173 wxDataObject *arg1 = (wxDataObject *) 0 ;
27174 wxDataFormat *arg2 = 0 ;
27175 PyObject *result;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self",(char *) "format", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 {
27186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(2)) SWIG_fail;
27188 if (arg2 == NULL) {
27189 SWIG_null_ref("wxDataFormat");
27190 }
27191 if (SWIG_arg_fail(2)) SWIG_fail;
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27196
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 resultobj = result;
27201 return resultobj;
27202 fail:
27203 return NULL;
27204 }
27205
27206
27207 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27208 PyObject *resultobj;
27209 wxDataObject *arg1 = (wxDataObject *) 0 ;
27210 wxDataFormat *arg2 = 0 ;
27211 PyObject *arg3 = (PyObject *) 0 ;
27212 bool result;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 PyObject * obj2 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self",(char *) "format",(char *) "data", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 {
27224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27225 if (SWIG_arg_fail(2)) SWIG_fail;
27226 if (arg2 == NULL) {
27227 SWIG_null_ref("wxDataFormat");
27228 }
27229 if (SWIG_arg_fail(2)) SWIG_fail;
27230 }
27231 arg3 = obj2;
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27235
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 {
27240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27249 PyObject *obj;
27250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27251 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27252 Py_INCREF(obj);
27253 return Py_BuildValue((char *)"");
27254 }
27255 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj;
27257 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27258 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27259 wxDataObjectSimple *result;
27260 PyObject * obj0 = 0 ;
27261 char *kwnames[] = {
27262 (char *) "format", NULL
27263 };
27264
27265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27266 if (obj0) {
27267 {
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 if (arg1 == NULL) {
27271 SWIG_null_ref("wxDataFormat");
27272 }
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 }
27275 }
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27279
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj;
27292 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27293 wxDataFormat *result;
27294 PyObject * obj0 = 0 ;
27295 char *kwnames[] = {
27296 (char *) "self", NULL
27297 };
27298
27299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27301 if (SWIG_arg_fail(1)) SWIG_fail;
27302 {
27303 PyThreadState* __tstate = wxPyBeginAllowThreads();
27304 {
27305 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27306 result = (wxDataFormat *) &_result_ref;
27307 }
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj;
27321 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27322 wxDataFormat *arg2 = 0 ;
27323 PyObject * obj0 = 0 ;
27324 PyObject * obj1 = 0 ;
27325 char *kwnames[] = {
27326 (char *) "self",(char *) "format", NULL
27327 };
27328
27329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27331 if (SWIG_arg_fail(1)) SWIG_fail;
27332 {
27333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27334 if (SWIG_arg_fail(2)) SWIG_fail;
27335 if (arg2 == NULL) {
27336 SWIG_null_ref("wxDataFormat");
27337 }
27338 if (SWIG_arg_fail(2)) SWIG_fail;
27339 }
27340 {
27341 PyThreadState* __tstate = wxPyBeginAllowThreads();
27342 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27343
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 Py_INCREF(Py_None); resultobj = Py_None;
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27355 PyObject *resultobj;
27356 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27357 size_t result;
27358 PyObject * obj0 = 0 ;
27359 char *kwnames[] = {
27360 (char *) "self", NULL
27361 };
27362
27363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27365 if (SWIG_arg_fail(1)) SWIG_fail;
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27369
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj;
27384 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27385 PyObject *result;
27386 PyObject * obj0 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 resultobj = result;
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27409 PyObject *resultobj;
27410 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27411 PyObject *arg2 = (PyObject *) 0 ;
27412 bool result;
27413 PyObject * obj0 = 0 ;
27414 PyObject * obj1 = 0 ;
27415 char *kwnames[] = {
27416 (char *) "self",(char *) "data", NULL
27417 };
27418
27419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(1)) SWIG_fail;
27422 arg2 = obj1;
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27426
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 {
27431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27432 }
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27440 PyObject *obj;
27441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27442 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27443 Py_INCREF(obj);
27444 return Py_BuildValue((char *)"");
27445 }
27446 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj;
27448 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27449 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27450 wxPyDataObjectSimple *result;
27451 PyObject * obj0 = 0 ;
27452 char *kwnames[] = {
27453 (char *) "format", NULL
27454 };
27455
27456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27457 if (obj0) {
27458 {
27459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27460 if (SWIG_arg_fail(1)) SWIG_fail;
27461 if (arg1 == NULL) {
27462 SWIG_null_ref("wxDataFormat");
27463 }
27464 if (SWIG_arg_fail(1)) SWIG_fail;
27465 }
27466 }
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27482 PyObject *resultobj;
27483 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27484 PyObject *arg2 = (PyObject *) 0 ;
27485 PyObject *arg3 = (PyObject *) 0 ;
27486 PyObject * obj0 = 0 ;
27487 PyObject * obj1 = 0 ;
27488 PyObject * obj2 = 0 ;
27489 char *kwnames[] = {
27490 (char *) "self",(char *) "self",(char *) "_class", NULL
27491 };
27492
27493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 arg2 = obj1;
27497 arg3 = obj2;
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->_setCallbackInfo(arg2,arg3);
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 Py_INCREF(Py_None); resultobj = Py_None;
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27513 PyObject *obj;
27514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27515 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27516 Py_INCREF(obj);
27517 return Py_BuildValue((char *)"");
27518 }
27519 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27520 PyObject *resultobj;
27521 wxDataObjectComposite *result;
27522 char *kwnames[] = {
27523 NULL
27524 };
27525
27526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27527 {
27528 PyThreadState* __tstate = wxPyBeginAllowThreads();
27529 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27530
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj;
27543 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27544 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27545 bool arg3 = (bool) false ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 PyObject * obj2 = 0 ;
27549 char *kwnames[] = {
27550 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27551 };
27552
27553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27555 if (SWIG_arg_fail(1)) SWIG_fail;
27556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27557 if (SWIG_arg_fail(2)) SWIG_fail;
27558 if (obj2) {
27559 {
27560 arg3 = (bool)(SWIG_As_bool(obj2));
27561 if (SWIG_arg_fail(3)) SWIG_fail;
27562 }
27563 }
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 (arg1)->Add(arg2,arg3);
27567
27568 wxPyEndAllowThreads(__tstate);
27569 if (PyErr_Occurred()) SWIG_fail;
27570 }
27571 Py_INCREF(Py_None); resultobj = Py_None;
27572 return resultobj;
27573 fail:
27574 return NULL;
27575 }
27576
27577
27578 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27579 PyObject *obj;
27580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27581 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27582 Py_INCREF(obj);
27583 return Py_BuildValue((char *)"");
27584 }
27585 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27586 PyObject *resultobj;
27587 wxString const &arg1_defvalue = wxPyEmptyString ;
27588 wxString *arg1 = (wxString *) &arg1_defvalue ;
27589 wxTextDataObject *result;
27590 bool temp1 = false ;
27591 PyObject * obj0 = 0 ;
27592 char *kwnames[] = {
27593 (char *) "text", NULL
27594 };
27595
27596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27597 if (obj0) {
27598 {
27599 arg1 = wxString_in_helper(obj0);
27600 if (arg1 == NULL) SWIG_fail;
27601 temp1 = true;
27602 }
27603 }
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27607
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27612 {
27613 if (temp1)
27614 delete arg1;
27615 }
27616 return resultobj;
27617 fail:
27618 {
27619 if (temp1)
27620 delete arg1;
27621 }
27622 return NULL;
27623 }
27624
27625
27626 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj;
27628 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27629 size_t result;
27630 PyObject * obj0 = 0 ;
27631 char *kwnames[] = {
27632 (char *) "self", NULL
27633 };
27634
27635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27637 if (SWIG_arg_fail(1)) SWIG_fail;
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 result = (size_t)(arg1)->GetTextLength();
27641
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 {
27646 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27647 }
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27655 PyObject *resultobj;
27656 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27657 wxString result;
27658 PyObject * obj0 = 0 ;
27659 char *kwnames[] = {
27660 (char *) "self", NULL
27661 };
27662
27663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27665 if (SWIG_arg_fail(1)) SWIG_fail;
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (arg1)->GetText();
27669
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 {
27674 #if wxUSE_UNICODE
27675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27676 #else
27677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27678 #endif
27679 }
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27687 PyObject *resultobj;
27688 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27689 wxString *arg2 = 0 ;
27690 bool temp2 = false ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 char *kwnames[] = {
27694 (char *) "self",(char *) "text", NULL
27695 };
27696
27697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27699 if (SWIG_arg_fail(1)) SWIG_fail;
27700 {
27701 arg2 = wxString_in_helper(obj1);
27702 if (arg2 == NULL) SWIG_fail;
27703 temp2 = true;
27704 }
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 (arg1)->SetText((wxString const &)*arg2);
27708
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 Py_INCREF(Py_None); resultobj = Py_None;
27713 {
27714 if (temp2)
27715 delete arg2;
27716 }
27717 return resultobj;
27718 fail:
27719 {
27720 if (temp2)
27721 delete arg2;
27722 }
27723 return NULL;
27724 }
27725
27726
27727 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27728 PyObject *obj;
27729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27730 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27731 Py_INCREF(obj);
27732 return Py_BuildValue((char *)"");
27733 }
27734 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj;
27736 wxString const &arg1_defvalue = wxPyEmptyString ;
27737 wxString *arg1 = (wxString *) &arg1_defvalue ;
27738 wxPyTextDataObject *result;
27739 bool temp1 = false ;
27740 PyObject * obj0 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "text", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27746 if (obj0) {
27747 {
27748 arg1 = wxString_in_helper(obj0);
27749 if (arg1 == NULL) SWIG_fail;
27750 temp1 = true;
27751 }
27752 }
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27761 {
27762 if (temp1)
27763 delete arg1;
27764 }
27765 return resultobj;
27766 fail:
27767 {
27768 if (temp1)
27769 delete arg1;
27770 }
27771 return NULL;
27772 }
27773
27774
27775 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj;
27777 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27778 PyObject *arg2 = (PyObject *) 0 ;
27779 PyObject *arg3 = (PyObject *) 0 ;
27780 PyObject * obj0 = 0 ;
27781 PyObject * obj1 = 0 ;
27782 PyObject * obj2 = 0 ;
27783 char *kwnames[] = {
27784 (char *) "self",(char *) "self",(char *) "_class", NULL
27785 };
27786
27787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27789 if (SWIG_arg_fail(1)) SWIG_fail;
27790 arg2 = obj1;
27791 arg3 = obj2;
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 (arg1)->_setCallbackInfo(arg2,arg3);
27795
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 Py_INCREF(Py_None); resultobj = Py_None;
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27807 PyObject *obj;
27808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27809 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27810 Py_INCREF(obj);
27811 return Py_BuildValue((char *)"");
27812 }
27813 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27816 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27817 wxBitmapDataObject *result;
27818 PyObject * obj0 = 0 ;
27819 char *kwnames[] = {
27820 (char *) "bitmap", NULL
27821 };
27822
27823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27824 if (obj0) {
27825 {
27826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(1)) SWIG_fail;
27828 if (arg1 == NULL) {
27829 SWIG_null_ref("wxBitmap");
27830 }
27831 if (SWIG_arg_fail(1)) SWIG_fail;
27832 }
27833 }
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27837
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27842 return resultobj;
27843 fail:
27844 return NULL;
27845 }
27846
27847
27848 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27849 PyObject *resultobj;
27850 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27851 wxBitmap result;
27852 PyObject * obj0 = 0 ;
27853 char *kwnames[] = {
27854 (char *) "self", NULL
27855 };
27856
27857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27859 if (SWIG_arg_fail(1)) SWIG_fail;
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27863
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 wxBitmap * resultptr;
27869 resultptr = new wxBitmap((wxBitmap &)(result));
27870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27871 }
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27879 PyObject *resultobj;
27880 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27881 wxBitmap *arg2 = 0 ;
27882 PyObject * obj0 = 0 ;
27883 PyObject * obj1 = 0 ;
27884 char *kwnames[] = {
27885 (char *) "self",(char *) "bitmap", NULL
27886 };
27887
27888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27890 if (SWIG_arg_fail(1)) SWIG_fail;
27891 {
27892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27893 if (SWIG_arg_fail(2)) SWIG_fail;
27894 if (arg2 == NULL) {
27895 SWIG_null_ref("wxBitmap");
27896 }
27897 if (SWIG_arg_fail(2)) SWIG_fail;
27898 }
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27902
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 Py_INCREF(Py_None); resultobj = Py_None;
27907 return resultobj;
27908 fail:
27909 return NULL;
27910 }
27911
27912
27913 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27914 PyObject *obj;
27915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27916 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27917 Py_INCREF(obj);
27918 return Py_BuildValue((char *)"");
27919 }
27920 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj;
27922 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27923 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27924 wxPyBitmapDataObject *result;
27925 PyObject * obj0 = 0 ;
27926 char *kwnames[] = {
27927 (char *) "bitmap", NULL
27928 };
27929
27930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27931 if (obj0) {
27932 {
27933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27934 if (SWIG_arg_fail(1)) SWIG_fail;
27935 if (arg1 == NULL) {
27936 SWIG_null_ref("wxBitmap");
27937 }
27938 if (SWIG_arg_fail(1)) SWIG_fail;
27939 }
27940 }
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj;
27957 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27958 PyObject *arg2 = (PyObject *) 0 ;
27959 PyObject *arg3 = (PyObject *) 0 ;
27960 PyObject * obj0 = 0 ;
27961 PyObject * obj1 = 0 ;
27962 PyObject * obj2 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "self",(char *) "self",(char *) "_class", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(1)) SWIG_fail;
27970 arg2 = obj1;
27971 arg3 = obj2;
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 (arg1)->_setCallbackInfo(arg2,arg3);
27975
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 Py_INCREF(Py_None); resultobj = Py_None;
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27987 PyObject *obj;
27988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27989 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27990 Py_INCREF(obj);
27991 return Py_BuildValue((char *)"");
27992 }
27993 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxFileDataObject *result;
27996 char *kwnames[] = {
27997 NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 result = (wxFileDataObject *)new wxFileDataObject();
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28016 PyObject *resultobj;
28017 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28018 wxArrayString *result;
28019 PyObject * obj0 = 0 ;
28020 char *kwnames[] = {
28021 (char *) "self", NULL
28022 };
28023
28024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28026 if (SWIG_arg_fail(1)) SWIG_fail;
28027 {
28028 PyThreadState* __tstate = wxPyBeginAllowThreads();
28029 {
28030 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28031 result = (wxArrayString *) &_result_ref;
28032 }
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 {
28038 resultobj = wxArrayString2PyList_helper(*result);
28039 }
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj;
28048 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28049 wxString *arg2 = 0 ;
28050 bool temp2 = false ;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 char *kwnames[] = {
28054 (char *) "self",(char *) "filename", NULL
28055 };
28056
28057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28059 if (SWIG_arg_fail(1)) SWIG_fail;
28060 {
28061 arg2 = wxString_in_helper(obj1);
28062 if (arg2 == NULL) SWIG_fail;
28063 temp2 = true;
28064 }
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 (arg1)->AddFile((wxString const &)*arg2);
28068
28069 wxPyEndAllowThreads(__tstate);
28070 if (PyErr_Occurred()) SWIG_fail;
28071 }
28072 Py_INCREF(Py_None); resultobj = Py_None;
28073 {
28074 if (temp2)
28075 delete arg2;
28076 }
28077 return resultobj;
28078 fail:
28079 {
28080 if (temp2)
28081 delete arg2;
28082 }
28083 return NULL;
28084 }
28085
28086
28087 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28088 PyObject *obj;
28089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28090 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28091 Py_INCREF(obj);
28092 return Py_BuildValue((char *)"");
28093 }
28094 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28095 PyObject *resultobj;
28096 wxDataFormat *arg1 = 0 ;
28097 wxCustomDataObject *result;
28098 PyObject * obj0 = 0 ;
28099
28100 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28101 {
28102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(1)) SWIG_fail;
28104 if (arg1 == NULL) {
28105 SWIG_null_ref("wxDataFormat");
28106 }
28107 if (SWIG_arg_fail(1)) SWIG_fail;
28108 }
28109 {
28110 PyThreadState* __tstate = wxPyBeginAllowThreads();
28111 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28112
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28124 PyObject *resultobj;
28125 wxString *arg1 = 0 ;
28126 wxCustomDataObject *result;
28127 bool temp1 = false ;
28128 PyObject * obj0 = 0 ;
28129
28130 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28131 {
28132 arg1 = wxString_in_helper(obj0);
28133 if (arg1 == NULL) SWIG_fail;
28134 temp1 = true;
28135 }
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28139
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28144 {
28145 if (temp1)
28146 delete arg1;
28147 }
28148 return resultobj;
28149 fail:
28150 {
28151 if (temp1)
28152 delete arg1;
28153 }
28154 return NULL;
28155 }
28156
28157
28158 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28159 PyObject *resultobj;
28160 wxCustomDataObject *result;
28161
28162 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 result = (wxCustomDataObject *)new wxCustomDataObject();
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28178 int argc;
28179 PyObject *argv[2];
28180 int ii;
28181
28182 argc = PyObject_Length(args);
28183 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28184 argv[ii] = PyTuple_GetItem(args,ii);
28185 }
28186 if (argc == 0) {
28187 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28188 }
28189 if (argc == 1) {
28190 int _v;
28191 {
28192 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28193 }
28194 if (_v) {
28195 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28196 }
28197 }
28198 if (argc == 1) {
28199 int _v;
28200 {
28201 void *ptr = 0;
28202 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28203 _v = 0;
28204 PyErr_Clear();
28205 } else {
28206 _v = (ptr != 0);
28207 }
28208 }
28209 if (_v) {
28210 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28211 }
28212 }
28213
28214 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28215 return NULL;
28216 }
28217
28218
28219 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj;
28221 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28222 PyObject *arg2 = (PyObject *) 0 ;
28223 bool result;
28224 PyObject * obj0 = 0 ;
28225 PyObject * obj1 = 0 ;
28226 char *kwnames[] = {
28227 (char *) "self",(char *) "data", NULL
28228 };
28229
28230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28232 if (SWIG_arg_fail(1)) SWIG_fail;
28233 arg2 = obj1;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28253 size_t result;
28254 PyObject * obj0 = 0 ;
28255 char *kwnames[] = {
28256 (char *) "self", NULL
28257 };
28258
28259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28261 if (SWIG_arg_fail(1)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (size_t)(arg1)->GetSize();
28265
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 {
28270 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28271 }
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28279 PyObject *resultobj;
28280 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28281 PyObject *result;
28282 PyObject * obj0 = 0 ;
28283 char *kwnames[] = {
28284 (char *) "self", NULL
28285 };
28286
28287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28289 if (SWIG_arg_fail(1)) SWIG_fail;
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28293
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = result;
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28305 PyObject *obj;
28306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28307 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28308 Py_INCREF(obj);
28309 return Py_BuildValue((char *)"");
28310 }
28311 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28312 PyObject *resultobj;
28313 wxURLDataObject *result;
28314 char *kwnames[] = {
28315 NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (wxURLDataObject *)new wxURLDataObject();
28322
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28327 return resultobj;
28328 fail:
28329 return NULL;
28330 }
28331
28332
28333 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28334 PyObject *resultobj;
28335 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28336 wxString result;
28337 PyObject * obj0 = 0 ;
28338 char *kwnames[] = {
28339 (char *) "self", NULL
28340 };
28341
28342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(1)) SWIG_fail;
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (arg1)->GetURL();
28348
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 {
28353 #if wxUSE_UNICODE
28354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28355 #else
28356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28357 #endif
28358 }
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28368 wxString *arg2 = 0 ;
28369 bool temp2 = false ;
28370 PyObject * obj0 = 0 ;
28371 PyObject * obj1 = 0 ;
28372 char *kwnames[] = {
28373 (char *) "self",(char *) "url", NULL
28374 };
28375
28376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28378 if (SWIG_arg_fail(1)) SWIG_fail;
28379 {
28380 arg2 = wxString_in_helper(obj1);
28381 if (arg2 == NULL) SWIG_fail;
28382 temp2 = true;
28383 }
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 (arg1)->SetURL((wxString const &)*arg2);
28387
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 Py_INCREF(Py_None); resultobj = Py_None;
28392 {
28393 if (temp2)
28394 delete arg2;
28395 }
28396 return resultobj;
28397 fail:
28398 {
28399 if (temp2)
28400 delete arg2;
28401 }
28402 return NULL;
28403 }
28404
28405
28406 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28407 PyObject *obj;
28408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28409 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28410 Py_INCREF(obj);
28411 return Py_BuildValue((char *)"");
28412 }
28413 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28414 PyObject *resultobj;
28415 wxMetafileDataObject *result;
28416 char *kwnames[] = {
28417 NULL
28418 };
28419
28420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28424
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28436 PyObject *resultobj;
28437 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28438 wxMetafile *arg2 = 0 ;
28439 PyObject * obj0 = 0 ;
28440 PyObject * obj1 = 0 ;
28441 char *kwnames[] = {
28442 (char *) "self",(char *) "metafile", NULL
28443 };
28444
28445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28447 if (SWIG_arg_fail(1)) SWIG_fail;
28448 {
28449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28450 if (SWIG_arg_fail(2)) SWIG_fail;
28451 if (arg2 == NULL) {
28452 SWIG_null_ref("wxMetafile");
28453 }
28454 if (SWIG_arg_fail(2)) SWIG_fail;
28455 }
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28459
28460 wxPyEndAllowThreads(__tstate);
28461 if (PyErr_Occurred()) SWIG_fail;
28462 }
28463 Py_INCREF(Py_None); resultobj = Py_None;
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28473 wxMetafile result;
28474 PyObject * obj0 = 0 ;
28475 char *kwnames[] = {
28476 (char *) "self", NULL
28477 };
28478
28479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28481 if (SWIG_arg_fail(1)) SWIG_fail;
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28485
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 wxMetafile * resultptr;
28491 resultptr = new wxMetafile((wxMetafile &)(result));
28492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28501 PyObject *obj;
28502 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28503 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28504 Py_INCREF(obj);
28505 return Py_BuildValue((char *)"");
28506 }
28507 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxDragResult arg1 ;
28510 bool result;
28511 PyObject * obj0 = 0 ;
28512 char *kwnames[] = {
28513 (char *) "res", NULL
28514 };
28515
28516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28517 {
28518 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28519 if (SWIG_arg_fail(1)) SWIG_fail;
28520 }
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28524
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28538 PyObject *resultobj;
28539 wxWindow *arg1 = (wxWindow *) 0 ;
28540 wxCursor const &arg2_defvalue = wxNullCursor ;
28541 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28542 wxCursor const &arg3_defvalue = wxNullCursor ;
28543 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28544 wxCursor const &arg4_defvalue = wxNullCursor ;
28545 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28546 wxPyDropSource *result;
28547 PyObject * obj0 = 0 ;
28548 PyObject * obj1 = 0 ;
28549 PyObject * obj2 = 0 ;
28550 PyObject * obj3 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 if (obj1) {
28559 {
28560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28561 if (SWIG_arg_fail(2)) SWIG_fail;
28562 if (arg2 == NULL) {
28563 SWIG_null_ref("wxCursor");
28564 }
28565 if (SWIG_arg_fail(2)) SWIG_fail;
28566 }
28567 }
28568 if (obj2) {
28569 {
28570 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28571 if (SWIG_arg_fail(3)) SWIG_fail;
28572 if (arg3 == NULL) {
28573 SWIG_null_ref("wxCursor");
28574 }
28575 if (SWIG_arg_fail(3)) SWIG_fail;
28576 }
28577 }
28578 if (obj3) {
28579 {
28580 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(4)) SWIG_fail;
28582 if (arg4 == NULL) {
28583 SWIG_null_ref("wxCursor");
28584 }
28585 if (SWIG_arg_fail(4)) SWIG_fail;
28586 }
28587 }
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28591
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28596 return resultobj;
28597 fail:
28598 return NULL;
28599 }
28600
28601
28602 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28603 PyObject *resultobj;
28604 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28605 PyObject *arg2 = (PyObject *) 0 ;
28606 PyObject *arg3 = (PyObject *) 0 ;
28607 int arg4 ;
28608 PyObject * obj0 = 0 ;
28609 PyObject * obj1 = 0 ;
28610 PyObject * obj2 = 0 ;
28611 PyObject * obj3 = 0 ;
28612 char *kwnames[] = {
28613 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28614 };
28615
28616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28618 if (SWIG_arg_fail(1)) SWIG_fail;
28619 arg2 = obj1;
28620 arg3 = obj2;
28621 {
28622 arg4 = (int)(SWIG_As_int(obj3));
28623 if (SWIG_arg_fail(4)) SWIG_fail;
28624 }
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28628
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 Py_INCREF(Py_None); resultobj = Py_None;
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28642 PyObject * obj0 = 0 ;
28643 char *kwnames[] = {
28644 (char *) "self", NULL
28645 };
28646
28647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28649 if (SWIG_arg_fail(1)) SWIG_fail;
28650 {
28651 PyThreadState* __tstate = wxPyBeginAllowThreads();
28652 delete arg1;
28653
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 Py_INCREF(Py_None); resultobj = Py_None;
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28665 PyObject *resultobj;
28666 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28667 wxDataObject *arg2 = 0 ;
28668 PyObject * obj0 = 0 ;
28669 PyObject * obj1 = 0 ;
28670 char *kwnames[] = {
28671 (char *) "self",(char *) "data", NULL
28672 };
28673
28674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28676 if (SWIG_arg_fail(1)) SWIG_fail;
28677 {
28678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28679 if (SWIG_arg_fail(2)) SWIG_fail;
28680 if (arg2 == NULL) {
28681 SWIG_null_ref("wxDataObject");
28682 }
28683 if (SWIG_arg_fail(2)) SWIG_fail;
28684 }
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 (arg1)->SetData(*arg2);
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 Py_INCREF(Py_None); resultobj = Py_None;
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28702 wxDataObject *result;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "self", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28710 if (SWIG_arg_fail(1)) SWIG_fail;
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 result = (wxDataObject *)(arg1)->GetDataObject();
28714
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28726 PyObject *resultobj;
28727 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28728 wxDragResult arg2 ;
28729 wxCursor *arg3 = 0 ;
28730 PyObject * obj0 = 0 ;
28731 PyObject * obj1 = 0 ;
28732 PyObject * obj2 = 0 ;
28733 char *kwnames[] = {
28734 (char *) "self",(char *) "res",(char *) "cursor", NULL
28735 };
28736
28737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28739 if (SWIG_arg_fail(1)) SWIG_fail;
28740 {
28741 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28742 if (SWIG_arg_fail(2)) SWIG_fail;
28743 }
28744 {
28745 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28746 if (SWIG_arg_fail(3)) SWIG_fail;
28747 if (arg3 == NULL) {
28748 SWIG_null_ref("wxCursor");
28749 }
28750 if (SWIG_arg_fail(3)) SWIG_fail;
28751 }
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28755
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 Py_INCREF(Py_None); resultobj = Py_None;
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28769 int arg2 = (int) wxDrag_CopyOnly ;
28770 wxDragResult result;
28771 PyObject * obj0 = 0 ;
28772 PyObject * obj1 = 0 ;
28773 char *kwnames[] = {
28774 (char *) "self",(char *) "flags", NULL
28775 };
28776
28777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28779 if (SWIG_arg_fail(1)) SWIG_fail;
28780 if (obj1) {
28781 {
28782 arg2 = (int)(SWIG_As_int(obj1));
28783 if (SWIG_arg_fail(2)) SWIG_fail;
28784 }
28785 }
28786 {
28787 PyThreadState* __tstate = wxPyBeginAllowThreads();
28788 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28789
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 resultobj = SWIG_From_int((result));
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj;
28802 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28803 wxDragResult arg2 ;
28804 bool result;
28805 PyObject * obj0 = 0 ;
28806 PyObject * obj1 = 0 ;
28807 char *kwnames[] = {
28808 (char *) "self",(char *) "effect", NULL
28809 };
28810
28811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28813 if (SWIG_arg_fail(1)) SWIG_fail;
28814 {
28815 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28816 if (SWIG_arg_fail(2)) SWIG_fail;
28817 }
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28821
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 {
28826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28827 }
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28835 PyObject *obj;
28836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28837 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28838 Py_INCREF(obj);
28839 return Py_BuildValue((char *)"");
28840 }
28841 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxDataObject *arg1 = (wxDataObject *) NULL ;
28844 wxPyDropTarget *result;
28845 PyObject * obj0 = 0 ;
28846 char *kwnames[] = {
28847 (char *) "dataObject", NULL
28848 };
28849
28850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28851 if (obj0) {
28852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28853 if (SWIG_arg_fail(1)) SWIG_fail;
28854 }
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj;
28871 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28872 PyObject *arg2 = (PyObject *) 0 ;
28873 PyObject *arg3 = (PyObject *) 0 ;
28874 PyObject * obj0 = 0 ;
28875 PyObject * obj1 = 0 ;
28876 PyObject * obj2 = 0 ;
28877 char *kwnames[] = {
28878 (char *) "self",(char *) "self",(char *) "_class", NULL
28879 };
28880
28881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28883 if (SWIG_arg_fail(1)) SWIG_fail;
28884 arg2 = obj1;
28885 arg3 = obj2;
28886 {
28887 PyThreadState* __tstate = wxPyBeginAllowThreads();
28888 (arg1)->_setCallbackInfo(arg2,arg3);
28889
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 Py_INCREF(Py_None); resultobj = Py_None;
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28901 PyObject *resultobj;
28902 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28903 PyObject * obj0 = 0 ;
28904 char *kwnames[] = {
28905 (char *) "self", NULL
28906 };
28907
28908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28910 if (SWIG_arg_fail(1)) SWIG_fail;
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 delete arg1;
28914
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 Py_INCREF(Py_None); resultobj = Py_None;
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj;
28927 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28928 wxDataObject *result;
28929 PyObject * obj0 = 0 ;
28930 char *kwnames[] = {
28931 (char *) "self", NULL
28932 };
28933
28934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28936 if (SWIG_arg_fail(1)) SWIG_fail;
28937 {
28938 PyThreadState* __tstate = wxPyBeginAllowThreads();
28939 result = (wxDataObject *)(arg1)->GetDataObject();
28940
28941 wxPyEndAllowThreads(__tstate);
28942 if (PyErr_Occurred()) SWIG_fail;
28943 }
28944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj;
28953 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28954 wxDataObject *arg2 = (wxDataObject *) 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 char *kwnames[] = {
28958 (char *) "self",(char *) "dataObject", NULL
28959 };
28960
28961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28963 if (SWIG_arg_fail(1)) SWIG_fail;
28964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28965 if (SWIG_arg_fail(2)) SWIG_fail;
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 (arg1)->SetDataObject(arg2);
28969
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 Py_INCREF(Py_None); resultobj = Py_None;
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj;
28982 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28983 int arg2 ;
28984 int arg3 ;
28985 wxDragResult arg4 ;
28986 wxDragResult result;
28987 PyObject * obj0 = 0 ;
28988 PyObject * obj1 = 0 ;
28989 PyObject * obj2 = 0 ;
28990 PyObject * obj3 = 0 ;
28991 char *kwnames[] = {
28992 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28993 };
28994
28995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28997 if (SWIG_arg_fail(1)) SWIG_fail;
28998 {
28999 arg2 = (int)(SWIG_As_int(obj1));
29000 if (SWIG_arg_fail(2)) SWIG_fail;
29001 }
29002 {
29003 arg3 = (int)(SWIG_As_int(obj2));
29004 if (SWIG_arg_fail(3)) SWIG_fail;
29005 }
29006 {
29007 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29008 if (SWIG_arg_fail(4)) SWIG_fail;
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29013
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 resultobj = SWIG_From_int((result));
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj;
29026 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29027 int arg2 ;
29028 int arg3 ;
29029 wxDragResult arg4 ;
29030 wxDragResult result;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 PyObject * obj2 = 0 ;
29034 PyObject * obj3 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 {
29043 arg2 = (int)(SWIG_As_int(obj1));
29044 if (SWIG_arg_fail(2)) SWIG_fail;
29045 }
29046 {
29047 arg3 = (int)(SWIG_As_int(obj2));
29048 if (SWIG_arg_fail(3)) SWIG_fail;
29049 }
29050 {
29051 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29052 if (SWIG_arg_fail(4)) SWIG_fail;
29053 }
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29057
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 resultobj = SWIG_From_int((result));
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29069 PyObject *resultobj;
29070 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29071 PyObject * obj0 = 0 ;
29072 char *kwnames[] = {
29073 (char *) "self", NULL
29074 };
29075
29076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29078 if (SWIG_arg_fail(1)) SWIG_fail;
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 (arg1)->base_OnLeave();
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 Py_INCREF(Py_None); resultobj = Py_None;
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj;
29095 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29096 int arg2 ;
29097 int arg3 ;
29098 bool result;
29099 PyObject * obj0 = 0 ;
29100 PyObject * obj1 = 0 ;
29101 PyObject * obj2 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "x",(char *) "y", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 arg2 = (int)(SWIG_As_int(obj1));
29111 if (SWIG_arg_fail(2)) SWIG_fail;
29112 }
29113 {
29114 arg3 = (int)(SWIG_As_int(obj2));
29115 if (SWIG_arg_fail(3)) SWIG_fail;
29116 }
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29120
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 {
29125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29126 }
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29136 bool result;
29137 PyObject * obj0 = 0 ;
29138 char *kwnames[] = {
29139 (char *) "self", NULL
29140 };
29141
29142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29144 if (SWIG_arg_fail(1)) SWIG_fail;
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 result = (bool)(arg1)->GetData();
29148
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 {
29153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29154 }
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj;
29163 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29164 wxDragResult arg2 ;
29165 PyObject * obj0 = 0 ;
29166 PyObject * obj1 = 0 ;
29167 char *kwnames[] = {
29168 (char *) "self",(char *) "action", NULL
29169 };
29170
29171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 {
29175 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29176 if (SWIG_arg_fail(2)) SWIG_fail;
29177 }
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 (arg1)->SetDefaultAction((wxDragResult )arg2);
29181
29182 wxPyEndAllowThreads(__tstate);
29183 if (PyErr_Occurred()) SWIG_fail;
29184 }
29185 Py_INCREF(Py_None); resultobj = Py_None;
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29193 PyObject *resultobj;
29194 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29195 wxDragResult result;
29196 PyObject * obj0 = 0 ;
29197 char *kwnames[] = {
29198 (char *) "self", NULL
29199 };
29200
29201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29203 if (SWIG_arg_fail(1)) SWIG_fail;
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (wxDragResult)(arg1)->GetDefaultAction();
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_From_int((result));
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29219 PyObject *obj;
29220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29221 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29222 Py_INCREF(obj);
29223 return Py_BuildValue((char *)"");
29224 }
29225 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj;
29227 wxPyTextDropTarget *result;
29228 char *kwnames[] = {
29229 NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29236
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29248 PyObject *resultobj;
29249 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29250 PyObject *arg2 = (PyObject *) 0 ;
29251 PyObject *arg3 = (PyObject *) 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 char *kwnames[] = {
29256 (char *) "self",(char *) "self",(char *) "_class", NULL
29257 };
29258
29259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(1)) SWIG_fail;
29262 arg2 = obj1;
29263 arg3 = obj2;
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 (arg1)->_setCallbackInfo(arg2,arg3);
29267
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 Py_INCREF(Py_None); resultobj = Py_None;
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj;
29280 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29281 int arg2 ;
29282 int arg3 ;
29283 wxDragResult arg4 ;
29284 wxDragResult result;
29285 PyObject * obj0 = 0 ;
29286 PyObject * obj1 = 0 ;
29287 PyObject * obj2 = 0 ;
29288 PyObject * obj3 = 0 ;
29289 char *kwnames[] = {
29290 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29291 };
29292
29293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29295 if (SWIG_arg_fail(1)) SWIG_fail;
29296 {
29297 arg2 = (int)(SWIG_As_int(obj1));
29298 if (SWIG_arg_fail(2)) SWIG_fail;
29299 }
29300 {
29301 arg3 = (int)(SWIG_As_int(obj2));
29302 if (SWIG_arg_fail(3)) SWIG_fail;
29303 }
29304 {
29305 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29306 if (SWIG_arg_fail(4)) SWIG_fail;
29307 }
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_From_int((result));
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj;
29324 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29325 int arg2 ;
29326 int arg3 ;
29327 wxDragResult arg4 ;
29328 wxDragResult result;
29329 PyObject * obj0 = 0 ;
29330 PyObject * obj1 = 0 ;
29331 PyObject * obj2 = 0 ;
29332 PyObject * obj3 = 0 ;
29333 char *kwnames[] = {
29334 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29335 };
29336
29337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(1)) SWIG_fail;
29340 {
29341 arg2 = (int)(SWIG_As_int(obj1));
29342 if (SWIG_arg_fail(2)) SWIG_fail;
29343 }
29344 {
29345 arg3 = (int)(SWIG_As_int(obj2));
29346 if (SWIG_arg_fail(3)) SWIG_fail;
29347 }
29348 {
29349 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29350 if (SWIG_arg_fail(4)) SWIG_fail;
29351 }
29352 {
29353 PyThreadState* __tstate = wxPyBeginAllowThreads();
29354 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29355
29356 wxPyEndAllowThreads(__tstate);
29357 if (PyErr_Occurred()) SWIG_fail;
29358 }
29359 resultobj = SWIG_From_int((result));
29360 return resultobj;
29361 fail:
29362 return NULL;
29363 }
29364
29365
29366 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29367 PyObject *resultobj;
29368 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29369 PyObject * obj0 = 0 ;
29370 char *kwnames[] = {
29371 (char *) "self", NULL
29372 };
29373
29374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29376 if (SWIG_arg_fail(1)) SWIG_fail;
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 (arg1)->base_OnLeave();
29380
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 Py_INCREF(Py_None); resultobj = Py_None;
29385 return resultobj;
29386 fail:
29387 return NULL;
29388 }
29389
29390
29391 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29392 PyObject *resultobj;
29393 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29394 int arg2 ;
29395 int arg3 ;
29396 bool result;
29397 PyObject * obj0 = 0 ;
29398 PyObject * obj1 = 0 ;
29399 PyObject * obj2 = 0 ;
29400 char *kwnames[] = {
29401 (char *) "self",(char *) "x",(char *) "y", NULL
29402 };
29403
29404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29406 if (SWIG_arg_fail(1)) SWIG_fail;
29407 {
29408 arg2 = (int)(SWIG_As_int(obj1));
29409 if (SWIG_arg_fail(2)) SWIG_fail;
29410 }
29411 {
29412 arg3 = (int)(SWIG_As_int(obj2));
29413 if (SWIG_arg_fail(3)) SWIG_fail;
29414 }
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 {
29423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29424 }
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29432 PyObject *resultobj;
29433 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29434 int arg2 ;
29435 int arg3 ;
29436 wxDragResult arg4 ;
29437 wxDragResult result;
29438 PyObject * obj0 = 0 ;
29439 PyObject * obj1 = 0 ;
29440 PyObject * obj2 = 0 ;
29441 PyObject * obj3 = 0 ;
29442 char *kwnames[] = {
29443 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29444 };
29445
29446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29448 if (SWIG_arg_fail(1)) SWIG_fail;
29449 {
29450 arg2 = (int)(SWIG_As_int(obj1));
29451 if (SWIG_arg_fail(2)) SWIG_fail;
29452 }
29453 {
29454 arg3 = (int)(SWIG_As_int(obj2));
29455 if (SWIG_arg_fail(3)) SWIG_fail;
29456 }
29457 {
29458 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29459 if (SWIG_arg_fail(4)) SWIG_fail;
29460 }
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29464
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 resultobj = SWIG_From_int((result));
29469 return resultobj;
29470 fail:
29471 return NULL;
29472 }
29473
29474
29475 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29476 PyObject *obj;
29477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29478 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29479 Py_INCREF(obj);
29480 return Py_BuildValue((char *)"");
29481 }
29482 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29483 PyObject *resultobj;
29484 wxPyFileDropTarget *result;
29485 char *kwnames[] = {
29486 NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29490 {
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29493
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29505 PyObject *resultobj;
29506 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29507 PyObject *arg2 = (PyObject *) 0 ;
29508 PyObject *arg3 = (PyObject *) 0 ;
29509 PyObject * obj0 = 0 ;
29510 PyObject * obj1 = 0 ;
29511 PyObject * obj2 = 0 ;
29512 char *kwnames[] = {
29513 (char *) "self",(char *) "self",(char *) "_class", NULL
29514 };
29515
29516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29518 if (SWIG_arg_fail(1)) SWIG_fail;
29519 arg2 = obj1;
29520 arg3 = obj2;
29521 {
29522 PyThreadState* __tstate = wxPyBeginAllowThreads();
29523 (arg1)->_setCallbackInfo(arg2,arg3);
29524
29525 wxPyEndAllowThreads(__tstate);
29526 if (PyErr_Occurred()) SWIG_fail;
29527 }
29528 Py_INCREF(Py_None); resultobj = Py_None;
29529 return resultobj;
29530 fail:
29531 return NULL;
29532 }
29533
29534
29535 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj;
29537 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29538 int arg2 ;
29539 int arg3 ;
29540 wxDragResult arg4 ;
29541 wxDragResult result;
29542 PyObject * obj0 = 0 ;
29543 PyObject * obj1 = 0 ;
29544 PyObject * obj2 = 0 ;
29545 PyObject * obj3 = 0 ;
29546 char *kwnames[] = {
29547 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29548 };
29549
29550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29552 if (SWIG_arg_fail(1)) SWIG_fail;
29553 {
29554 arg2 = (int)(SWIG_As_int(obj1));
29555 if (SWIG_arg_fail(2)) SWIG_fail;
29556 }
29557 {
29558 arg3 = (int)(SWIG_As_int(obj2));
29559 if (SWIG_arg_fail(3)) SWIG_fail;
29560 }
29561 {
29562 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29563 if (SWIG_arg_fail(4)) SWIG_fail;
29564 }
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_From_int((result));
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj;
29581 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29582 int arg2 ;
29583 int arg3 ;
29584 wxDragResult arg4 ;
29585 wxDragResult result;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 PyObject * obj2 = 0 ;
29589 PyObject * obj3 = 0 ;
29590 char *kwnames[] = {
29591 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29592 };
29593
29594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29596 if (SWIG_arg_fail(1)) SWIG_fail;
29597 {
29598 arg2 = (int)(SWIG_As_int(obj1));
29599 if (SWIG_arg_fail(2)) SWIG_fail;
29600 }
29601 {
29602 arg3 = (int)(SWIG_As_int(obj2));
29603 if (SWIG_arg_fail(3)) SWIG_fail;
29604 }
29605 {
29606 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29607 if (SWIG_arg_fail(4)) SWIG_fail;
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 resultobj = SWIG_From_int((result));
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj;
29625 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29626 PyObject * obj0 = 0 ;
29627 char *kwnames[] = {
29628 (char *) "self", NULL
29629 };
29630
29631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29633 if (SWIG_arg_fail(1)) SWIG_fail;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 (arg1)->base_OnLeave();
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 Py_INCREF(Py_None); resultobj = Py_None;
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj;
29650 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29651 int arg2 ;
29652 int arg3 ;
29653 bool result;
29654 PyObject * obj0 = 0 ;
29655 PyObject * obj1 = 0 ;
29656 PyObject * obj2 = 0 ;
29657 char *kwnames[] = {
29658 (char *) "self",(char *) "x",(char *) "y", NULL
29659 };
29660
29661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29663 if (SWIG_arg_fail(1)) SWIG_fail;
29664 {
29665 arg2 = (int)(SWIG_As_int(obj1));
29666 if (SWIG_arg_fail(2)) SWIG_fail;
29667 }
29668 {
29669 arg3 = (int)(SWIG_As_int(obj2));
29670 if (SWIG_arg_fail(3)) SWIG_fail;
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 {
29680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29681 }
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29689 PyObject *resultobj;
29690 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29691 int arg2 ;
29692 int arg3 ;
29693 wxDragResult arg4 ;
29694 wxDragResult result;
29695 PyObject * obj0 = 0 ;
29696 PyObject * obj1 = 0 ;
29697 PyObject * obj2 = 0 ;
29698 PyObject * obj3 = 0 ;
29699 char *kwnames[] = {
29700 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29701 };
29702
29703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29705 if (SWIG_arg_fail(1)) SWIG_fail;
29706 {
29707 arg2 = (int)(SWIG_As_int(obj1));
29708 if (SWIG_arg_fail(2)) SWIG_fail;
29709 }
29710 {
29711 arg3 = (int)(SWIG_As_int(obj2));
29712 if (SWIG_arg_fail(3)) SWIG_fail;
29713 }
29714 {
29715 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29716 if (SWIG_arg_fail(4)) SWIG_fail;
29717 }
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29721
29722 wxPyEndAllowThreads(__tstate);
29723 if (PyErr_Occurred()) SWIG_fail;
29724 }
29725 resultobj = SWIG_From_int((result));
29726 return resultobj;
29727 fail:
29728 return NULL;
29729 }
29730
29731
29732 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29733 PyObject *obj;
29734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29735 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29736 Py_INCREF(obj);
29737 return Py_BuildValue((char *)"");
29738 }
29739 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29740 PyObject *resultobj;
29741 wxClipboard *result;
29742 char *kwnames[] = {
29743 NULL
29744 };
29745
29746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29747 {
29748 PyThreadState* __tstate = wxPyBeginAllowThreads();
29749 result = (wxClipboard *)new wxClipboard();
29750
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29762 PyObject *resultobj;
29763 wxClipboard *arg1 = (wxClipboard *) 0 ;
29764 PyObject * obj0 = 0 ;
29765 char *kwnames[] = {
29766 (char *) "self", NULL
29767 };
29768
29769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29771 if (SWIG_arg_fail(1)) SWIG_fail;
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 delete arg1;
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 Py_INCREF(Py_None); resultobj = Py_None;
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj;
29788 wxClipboard *arg1 = (wxClipboard *) 0 ;
29789 bool result;
29790 PyObject * obj0 = 0 ;
29791 char *kwnames[] = {
29792 (char *) "self", NULL
29793 };
29794
29795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29797 if (SWIG_arg_fail(1)) SWIG_fail;
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (bool)(arg1)->Open();
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 {
29806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29807 }
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxClipboard *arg1 = (wxClipboard *) 0 ;
29817 PyObject * obj0 = 0 ;
29818 char *kwnames[] = {
29819 (char *) "self", NULL
29820 };
29821
29822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29824 if (SWIG_arg_fail(1)) SWIG_fail;
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 (arg1)->Close();
29828
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 Py_INCREF(Py_None); resultobj = Py_None;
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29840 PyObject *resultobj;
29841 wxClipboard *arg1 = (wxClipboard *) 0 ;
29842 bool result;
29843 PyObject * obj0 = 0 ;
29844 char *kwnames[] = {
29845 (char *) "self", NULL
29846 };
29847
29848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29850 if (SWIG_arg_fail(1)) SWIG_fail;
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29854
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 {
29859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29860 }
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxClipboard *arg1 = (wxClipboard *) 0 ;
29870 wxDataObject *arg2 = (wxDataObject *) 0 ;
29871 bool result;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char *kwnames[] = {
29875 (char *) "self",(char *) "data", NULL
29876 };
29877
29878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29880 if (SWIG_arg_fail(1)) SWIG_fail;
29881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29882 if (SWIG_arg_fail(2)) SWIG_fail;
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 result = (bool)(arg1)->AddData(arg2);
29886
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 {
29891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29892 }
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29900 PyObject *resultobj;
29901 wxClipboard *arg1 = (wxClipboard *) 0 ;
29902 wxDataObject *arg2 = (wxDataObject *) 0 ;
29903 bool result;
29904 PyObject * obj0 = 0 ;
29905 PyObject * obj1 = 0 ;
29906 char *kwnames[] = {
29907 (char *) "self",(char *) "data", NULL
29908 };
29909
29910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29912 if (SWIG_arg_fail(1)) SWIG_fail;
29913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29914 if (SWIG_arg_fail(2)) SWIG_fail;
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)(arg1)->SetData(arg2);
29918
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj;
29933 wxClipboard *arg1 = (wxClipboard *) 0 ;
29934 wxDataFormat *arg2 = 0 ;
29935 bool result;
29936 PyObject * obj0 = 0 ;
29937 PyObject * obj1 = 0 ;
29938 char *kwnames[] = {
29939 (char *) "self",(char *) "format", NULL
29940 };
29941
29942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29944 if (SWIG_arg_fail(1)) SWIG_fail;
29945 {
29946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29947 if (SWIG_arg_fail(2)) SWIG_fail;
29948 if (arg2 == NULL) {
29949 SWIG_null_ref("wxDataFormat");
29950 }
29951 if (SWIG_arg_fail(2)) SWIG_fail;
29952 }
29953 {
29954 PyThreadState* __tstate = wxPyBeginAllowThreads();
29955 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29956
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 {
29961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29962 }
29963 return resultobj;
29964 fail:
29965 return NULL;
29966 }
29967
29968
29969 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29970 PyObject *resultobj;
29971 wxClipboard *arg1 = (wxClipboard *) 0 ;
29972 wxDataObject *arg2 = 0 ;
29973 bool result;
29974 PyObject * obj0 = 0 ;
29975 PyObject * obj1 = 0 ;
29976 char *kwnames[] = {
29977 (char *) "self",(char *) "data", NULL
29978 };
29979
29980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29982 if (SWIG_arg_fail(1)) SWIG_fail;
29983 {
29984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29985 if (SWIG_arg_fail(2)) SWIG_fail;
29986 if (arg2 == NULL) {
29987 SWIG_null_ref("wxDataObject");
29988 }
29989 if (SWIG_arg_fail(2)) SWIG_fail;
29990 }
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 result = (bool)(arg1)->GetData(*arg2);
29994
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 {
29999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30000 }
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj;
30009 wxClipboard *arg1 = (wxClipboard *) 0 ;
30010 PyObject * obj0 = 0 ;
30011 char *kwnames[] = {
30012 (char *) "self", NULL
30013 };
30014
30015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(1)) SWIG_fail;
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 (arg1)->Clear();
30021
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 Py_INCREF(Py_None); resultobj = Py_None;
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj;
30034 wxClipboard *arg1 = (wxClipboard *) 0 ;
30035 bool result;
30036 PyObject * obj0 = 0 ;
30037 char *kwnames[] = {
30038 (char *) "self", NULL
30039 };
30040
30041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30043 if (SWIG_arg_fail(1)) SWIG_fail;
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (bool)(arg1)->Flush();
30047
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 {
30052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30053 }
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj;
30062 wxClipboard *arg1 = (wxClipboard *) 0 ;
30063 bool arg2 = (bool) true ;
30064 PyObject * obj0 = 0 ;
30065 PyObject * obj1 = 0 ;
30066 char *kwnames[] = {
30067 (char *) "self",(char *) "primary", NULL
30068 };
30069
30070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30072 if (SWIG_arg_fail(1)) SWIG_fail;
30073 if (obj1) {
30074 {
30075 arg2 = (bool)(SWIG_As_bool(obj1));
30076 if (SWIG_arg_fail(2)) SWIG_fail;
30077 }
30078 }
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 (arg1)->UsePrimarySelection(arg2);
30082
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 Py_INCREF(Py_None); resultobj = Py_None;
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30094 PyObject *resultobj;
30095 wxClipboard *result;
30096 char *kwnames[] = {
30097 NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 result = (wxClipboard *)wxClipboard::Get();
30104
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30116 PyObject *obj;
30117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30118 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30119 Py_INCREF(obj);
30120 return Py_BuildValue((char *)"");
30121 }
30122 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30123 PyObject *resultobj;
30124 wxClipboard *arg1 = (wxClipboard *) NULL ;
30125 wxClipboardLocker *result;
30126 PyObject * obj0 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "clipboard", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30132 if (obj0) {
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 }
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj;
30152 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30153 PyObject * obj0 = 0 ;
30154 char *kwnames[] = {
30155 (char *) "self", NULL
30156 };
30157
30158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30160 if (SWIG_arg_fail(1)) SWIG_fail;
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 delete arg1;
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30178 bool result;
30179 PyObject * obj0 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = (bool)wxClipboardLocker___nonzero__(arg1);
30190
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 {
30195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30196 }
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30204 PyObject *obj;
30205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30206 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30207 Py_INCREF(obj);
30208 return Py_BuildValue((char *)"");
30209 }
30210 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30211 PyObject *resultobj;
30212 int arg1 = (int) 0 ;
30213 int arg2 = (int) 0 ;
30214 int arg3 = (int) 0 ;
30215 int arg4 = (int) 0 ;
30216 wxVideoMode *result;
30217 PyObject * obj0 = 0 ;
30218 PyObject * obj1 = 0 ;
30219 PyObject * obj2 = 0 ;
30220 PyObject * obj3 = 0 ;
30221 char *kwnames[] = {
30222 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30223 };
30224
30225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30226 if (obj0) {
30227 {
30228 arg1 = (int)(SWIG_As_int(obj0));
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 }
30231 }
30232 if (obj1) {
30233 {
30234 arg2 = (int)(SWIG_As_int(obj1));
30235 if (SWIG_arg_fail(2)) SWIG_fail;
30236 }
30237 }
30238 if (obj2) {
30239 {
30240 arg3 = (int)(SWIG_As_int(obj2));
30241 if (SWIG_arg_fail(3)) SWIG_fail;
30242 }
30243 }
30244 if (obj3) {
30245 {
30246 arg4 = (int)(SWIG_As_int(obj3));
30247 if (SWIG_arg_fail(4)) SWIG_fail;
30248 }
30249 }
30250 {
30251 PyThreadState* __tstate = wxPyBeginAllowThreads();
30252 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30253
30254 wxPyEndAllowThreads(__tstate);
30255 if (PyErr_Occurred()) SWIG_fail;
30256 }
30257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj;
30266 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30267 PyObject * obj0 = 0 ;
30268 char *kwnames[] = {
30269 (char *) "self", NULL
30270 };
30271
30272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30274 if (SWIG_arg_fail(1)) SWIG_fail;
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 delete arg1;
30278
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 Py_INCREF(Py_None); resultobj = Py_None;
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj;
30291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30292 wxVideoMode *arg2 = 0 ;
30293 bool result;
30294 PyObject * obj0 = 0 ;
30295 PyObject * obj1 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "self",(char *) "other", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30302 if (SWIG_arg_fail(1)) SWIG_fail;
30303 {
30304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30305 if (SWIG_arg_fail(2)) SWIG_fail;
30306 if (arg2 == NULL) {
30307 SWIG_null_ref("wxVideoMode");
30308 }
30309 if (SWIG_arg_fail(2)) SWIG_fail;
30310 }
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30314
30315 wxPyEndAllowThreads(__tstate);
30316 if (PyErr_Occurred()) SWIG_fail;
30317 }
30318 {
30319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30320 }
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30328 PyObject *resultobj;
30329 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30330 int result;
30331 PyObject * obj0 = 0 ;
30332 char *kwnames[] = {
30333 (char *) "self", NULL
30334 };
30335
30336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30338 if (SWIG_arg_fail(1)) SWIG_fail;
30339 {
30340 PyThreadState* __tstate = wxPyBeginAllowThreads();
30341 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30342
30343 wxPyEndAllowThreads(__tstate);
30344 if (PyErr_Occurred()) SWIG_fail;
30345 }
30346 {
30347 resultobj = SWIG_From_int((int)(result));
30348 }
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30356 PyObject *resultobj;
30357 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30358 int result;
30359 PyObject * obj0 = 0 ;
30360 char *kwnames[] = {
30361 (char *) "self", NULL
30362 };
30363
30364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30366 if (SWIG_arg_fail(1)) SWIG_fail;
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30370
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 {
30375 resultobj = SWIG_From_int((int)(result));
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj;
30385 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30386 int result;
30387 PyObject * obj0 = 0 ;
30388 char *kwnames[] = {
30389 (char *) "self", NULL
30390 };
30391
30392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30394 if (SWIG_arg_fail(1)) SWIG_fail;
30395 {
30396 PyThreadState* __tstate = wxPyBeginAllowThreads();
30397 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30398
30399 wxPyEndAllowThreads(__tstate);
30400 if (PyErr_Occurred()) SWIG_fail;
30401 }
30402 {
30403 resultobj = SWIG_From_int((int)(result));
30404 }
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj;
30413 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30414 bool result;
30415 PyObject * obj0 = 0 ;
30416 char *kwnames[] = {
30417 (char *) "self", NULL
30418 };
30419
30420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(1)) SWIG_fail;
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30426
30427 wxPyEndAllowThreads(__tstate);
30428 if (PyErr_Occurred()) SWIG_fail;
30429 }
30430 {
30431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30432 }
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj;
30441 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30442 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30443 bool result;
30444 PyObject * obj0 = 0 ;
30445 PyObject * obj1 = 0 ;
30446 char *kwnames[] = {
30447 (char *) "self",(char *) "other", NULL
30448 };
30449
30450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30452 if (SWIG_arg_fail(1)) SWIG_fail;
30453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30454 if (SWIG_arg_fail(2)) SWIG_fail;
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30458
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 {
30463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30464 }
30465 return resultobj;
30466 fail:
30467 return NULL;
30468 }
30469
30470
30471 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30472 PyObject *resultobj;
30473 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30474 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30475 bool result;
30476 PyObject * obj0 = 0 ;
30477 PyObject * obj1 = 0 ;
30478 char *kwnames[] = {
30479 (char *) "self",(char *) "other", NULL
30480 };
30481
30482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30484 if (SWIG_arg_fail(1)) SWIG_fail;
30485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30486 if (SWIG_arg_fail(2)) SWIG_fail;
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30490
30491 wxPyEndAllowThreads(__tstate);
30492 if (PyErr_Occurred()) SWIG_fail;
30493 }
30494 {
30495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30496 }
30497 return resultobj;
30498 fail:
30499 return NULL;
30500 }
30501
30502
30503 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30504 PyObject *resultobj;
30505 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30506 int arg2 ;
30507 PyObject * obj0 = 0 ;
30508 PyObject * obj1 = 0 ;
30509 char *kwnames[] = {
30510 (char *) "self",(char *) "w", NULL
30511 };
30512
30513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30515 if (SWIG_arg_fail(1)) SWIG_fail;
30516 {
30517 arg2 = (int)(SWIG_As_int(obj1));
30518 if (SWIG_arg_fail(2)) SWIG_fail;
30519 }
30520 if (arg1) (arg1)->w = arg2;
30521
30522 Py_INCREF(Py_None); resultobj = Py_None;
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30530 PyObject *resultobj;
30531 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30532 int result;
30533 PyObject * obj0 = 0 ;
30534 char *kwnames[] = {
30535 (char *) "self", NULL
30536 };
30537
30538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30540 if (SWIG_arg_fail(1)) SWIG_fail;
30541 result = (int) ((arg1)->w);
30542
30543 {
30544 resultobj = SWIG_From_int((int)(result));
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30555 int arg2 ;
30556 PyObject * obj0 = 0 ;
30557 PyObject * obj1 = 0 ;
30558 char *kwnames[] = {
30559 (char *) "self",(char *) "h", NULL
30560 };
30561
30562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(1)) SWIG_fail;
30565 {
30566 arg2 = (int)(SWIG_As_int(obj1));
30567 if (SWIG_arg_fail(2)) SWIG_fail;
30568 }
30569 if (arg1) (arg1)->h = arg2;
30570
30571 Py_INCREF(Py_None); resultobj = Py_None;
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj;
30580 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30581 int result;
30582 PyObject * obj0 = 0 ;
30583 char *kwnames[] = {
30584 (char *) "self", NULL
30585 };
30586
30587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30589 if (SWIG_arg_fail(1)) SWIG_fail;
30590 result = (int) ((arg1)->h);
30591
30592 {
30593 resultobj = SWIG_From_int((int)(result));
30594 }
30595 return resultobj;
30596 fail:
30597 return NULL;
30598 }
30599
30600
30601 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30602 PyObject *resultobj;
30603 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30604 int arg2 ;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self",(char *) "bpp", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 {
30615 arg2 = (int)(SWIG_As_int(obj1));
30616 if (SWIG_arg_fail(2)) SWIG_fail;
30617 }
30618 if (arg1) (arg1)->bpp = arg2;
30619
30620 Py_INCREF(Py_None); resultobj = Py_None;
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30630 int result;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "self", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30638 if (SWIG_arg_fail(1)) SWIG_fail;
30639 result = (int) ((arg1)->bpp);
30640
30641 {
30642 resultobj = SWIG_From_int((int)(result));
30643 }
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj;
30652 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30653 int arg2 ;
30654 PyObject * obj0 = 0 ;
30655 PyObject * obj1 = 0 ;
30656 char *kwnames[] = {
30657 (char *) "self",(char *) "refresh", NULL
30658 };
30659
30660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30662 if (SWIG_arg_fail(1)) SWIG_fail;
30663 {
30664 arg2 = (int)(SWIG_As_int(obj1));
30665 if (SWIG_arg_fail(2)) SWIG_fail;
30666 }
30667 if (arg1) (arg1)->refresh = arg2;
30668
30669 Py_INCREF(Py_None); resultobj = Py_None;
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj;
30678 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30679 int result;
30680 PyObject * obj0 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 result = (int) ((arg1)->refresh);
30689
30690 {
30691 resultobj = SWIG_From_int((int)(result));
30692 }
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30700 PyObject *obj;
30701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30702 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30703 Py_INCREF(obj);
30704 return Py_BuildValue((char *)"");
30705 }
30706 static int _wrap_DefaultVideoMode_set(PyObject *) {
30707 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30708 return 1;
30709 }
30710
30711
30712 static PyObject *_wrap_DefaultVideoMode_get(void) {
30713 PyObject *pyobj;
30714
30715 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30716 return pyobj;
30717 }
30718
30719
30720 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj;
30722 size_t arg1 = (size_t) 0 ;
30723 wxDisplay *result;
30724 PyObject * obj0 = 0 ;
30725 char *kwnames[] = {
30726 (char *) "index", NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30730 if (obj0) {
30731 {
30732 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30733 if (SWIG_arg_fail(1)) SWIG_fail;
30734 }
30735 }
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = (wxDisplay *)new wxDisplay(arg1);
30739
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj;
30752 wxDisplay *arg1 = (wxDisplay *) 0 ;
30753 PyObject * obj0 = 0 ;
30754 char *kwnames[] = {
30755 (char *) "self", NULL
30756 };
30757
30758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30760 if (SWIG_arg_fail(1)) SWIG_fail;
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 delete arg1;
30764
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 Py_INCREF(Py_None); resultobj = Py_None;
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj;
30777 size_t result;
30778 char *kwnames[] = {
30779 NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30783 {
30784 PyThreadState* __tstate = wxPyBeginAllowThreads();
30785 result = (size_t)wxDisplay::GetCount();
30786
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 {
30791 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30792 }
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj;
30801 wxPoint *arg1 = 0 ;
30802 int result;
30803 wxPoint temp1 ;
30804 PyObject * obj0 = 0 ;
30805 char *kwnames[] = {
30806 (char *) "pt", NULL
30807 };
30808
30809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30810 {
30811 arg1 = &temp1;
30812 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30813 }
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30817
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 resultobj = SWIG_From_int((int)(result));
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 int result;
30834 PyObject * obj0 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "window", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30841 if (SWIG_arg_fail(1)) SWIG_fail;
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 result = (int)Display_GetFromWindow(arg1);
30845
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 {
30850 resultobj = SWIG_From_int((int)(result));
30851 }
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30859 PyObject *resultobj;
30860 wxDisplay *arg1 = (wxDisplay *) 0 ;
30861 bool result;
30862 PyObject * obj0 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30869 if (SWIG_arg_fail(1)) SWIG_fail;
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (bool)((wxDisplay const *)arg1)->IsOk();
30873
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 {
30878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30879 }
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 wxDisplay *arg1 = (wxDisplay *) 0 ;
30889 wxRect result;
30890 PyObject * obj0 = 0 ;
30891 char *kwnames[] = {
30892 (char *) "self", NULL
30893 };
30894
30895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30897 if (SWIG_arg_fail(1)) SWIG_fail;
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = ((wxDisplay const *)arg1)->GetGeometry();
30901
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 {
30906 wxRect * resultptr;
30907 resultptr = new wxRect((wxRect &)(result));
30908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30909 }
30910 return resultobj;
30911 fail:
30912 return NULL;
30913 }
30914
30915
30916 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30917 PyObject *resultobj;
30918 wxDisplay *arg1 = (wxDisplay *) 0 ;
30919 wxString result;
30920 PyObject * obj0 = 0 ;
30921 char *kwnames[] = {
30922 (char *) "self", NULL
30923 };
30924
30925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30927 if (SWIG_arg_fail(1)) SWIG_fail;
30928 {
30929 PyThreadState* __tstate = wxPyBeginAllowThreads();
30930 result = ((wxDisplay const *)arg1)->GetName();
30931
30932 wxPyEndAllowThreads(__tstate);
30933 if (PyErr_Occurred()) SWIG_fail;
30934 }
30935 {
30936 #if wxUSE_UNICODE
30937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30938 #else
30939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30940 #endif
30941 }
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj;
30950 wxDisplay *arg1 = (wxDisplay *) 0 ;
30951 bool result;
30952 PyObject * obj0 = 0 ;
30953 char *kwnames[] = {
30954 (char *) "self", NULL
30955 };
30956
30957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30959 if (SWIG_arg_fail(1)) SWIG_fail;
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30963
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 {
30968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30969 }
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30977 PyObject *resultobj;
30978 wxDisplay *arg1 = (wxDisplay *) 0 ;
30979 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30980 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30981 PyObject *result;
30982 PyObject * obj0 = 0 ;
30983 PyObject * obj1 = 0 ;
30984 char *kwnames[] = {
30985 (char *) "self",(char *) "mode", NULL
30986 };
30987
30988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30990 if (SWIG_arg_fail(1)) SWIG_fail;
30991 if (obj1) {
30992 {
30993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30994 if (SWIG_arg_fail(2)) SWIG_fail;
30995 if (arg2 == NULL) {
30996 SWIG_null_ref("wxVideoMode");
30997 }
30998 if (SWIG_arg_fail(2)) SWIG_fail;
30999 }
31000 }
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31004
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 resultobj = result;
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31016 PyObject *resultobj;
31017 wxDisplay *arg1 = (wxDisplay *) 0 ;
31018 wxVideoMode result;
31019 PyObject * obj0 = 0 ;
31020 char *kwnames[] = {
31021 (char *) "self", NULL
31022 };
31023
31024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31026 if (SWIG_arg_fail(1)) SWIG_fail;
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31030
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 {
31035 wxVideoMode * resultptr;
31036 resultptr = new wxVideoMode((wxVideoMode &)(result));
31037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31038 }
31039 return resultobj;
31040 fail:
31041 return NULL;
31042 }
31043
31044
31045 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31046 PyObject *resultobj;
31047 wxDisplay *arg1 = (wxDisplay *) 0 ;
31048 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31049 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31050 bool result;
31051 PyObject * obj0 = 0 ;
31052 PyObject * obj1 = 0 ;
31053 char *kwnames[] = {
31054 (char *) "self",(char *) "mode", NULL
31055 };
31056
31057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31059 if (SWIG_arg_fail(1)) SWIG_fail;
31060 if (obj1) {
31061 {
31062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31063 if (SWIG_arg_fail(2)) SWIG_fail;
31064 if (arg2 == NULL) {
31065 SWIG_null_ref("wxVideoMode");
31066 }
31067 if (SWIG_arg_fail(2)) SWIG_fail;
31068 }
31069 }
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 {
31078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxDisplay *arg1 = (wxDisplay *) 0 ;
31089 PyObject * obj0 = 0 ;
31090 char *kwnames[] = {
31091 (char *) "self", NULL
31092 };
31093
31094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31096 if (SWIG_arg_fail(1)) SWIG_fail;
31097 {
31098 PyThreadState* __tstate = wxPyBeginAllowThreads();
31099 (arg1)->ResetMode();
31100
31101 wxPyEndAllowThreads(__tstate);
31102 if (PyErr_Occurred()) SWIG_fail;
31103 }
31104 Py_INCREF(Py_None); resultobj = Py_None;
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31112 PyObject *obj;
31113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31114 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31115 Py_INCREF(obj);
31116 return Py_BuildValue((char *)"");
31117 }
31118 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj;
31120 wxStandardPaths *result;
31121 char *kwnames[] = {
31122 NULL
31123 };
31124
31125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 result = (wxStandardPaths *)StandardPaths_Get();
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31143 wxString result;
31144 PyObject * obj0 = 0 ;
31145 char *kwnames[] = {
31146 (char *) "self", NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31151 if (SWIG_arg_fail(1)) SWIG_fail;
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31155
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 {
31160 #if wxUSE_UNICODE
31161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31162 #else
31163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31164 #endif
31165 }
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj;
31174 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31175 wxString result;
31176 PyObject * obj0 = 0 ;
31177 char *kwnames[] = {
31178 (char *) "self", NULL
31179 };
31180
31181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31183 if (SWIG_arg_fail(1)) SWIG_fail;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31187
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 {
31192 #if wxUSE_UNICODE
31193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31194 #else
31195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31196 #endif
31197 }
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31205 PyObject *resultobj;
31206 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31207 wxString result;
31208 PyObject * obj0 = 0 ;
31209 char *kwnames[] = {
31210 (char *) "self", NULL
31211 };
31212
31213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31215 if (SWIG_arg_fail(1)) SWIG_fail;
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31219
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 {
31224 #if wxUSE_UNICODE
31225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31226 #else
31227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31228 #endif
31229 }
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31237 PyObject *resultobj;
31238 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31239 wxString result;
31240 PyObject * obj0 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 {
31256 #if wxUSE_UNICODE
31257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31258 #else
31259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31260 #endif
31261 }
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj;
31270 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31271 wxString result;
31272 PyObject * obj0 = 0 ;
31273 char *kwnames[] = {
31274 (char *) "self", NULL
31275 };
31276
31277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31279 if (SWIG_arg_fail(1)) SWIG_fail;
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31283
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 {
31288 #if wxUSE_UNICODE
31289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31290 #else
31291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31292 #endif
31293 }
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31301 PyObject *resultobj;
31302 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31303 wxString result;
31304 PyObject * obj0 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31315
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 {
31320 #if wxUSE_UNICODE
31321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31322 #else
31323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31324 #endif
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31335 wxString result;
31336 PyObject * obj0 = 0 ;
31337 char *kwnames[] = {
31338 (char *) "self", NULL
31339 };
31340
31341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(1)) SWIG_fail;
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31347
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 {
31352 #if wxUSE_UNICODE
31353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31354 #else
31355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31356 #endif
31357 }
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj;
31366 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31367 wxString *arg2 = 0 ;
31368 bool temp2 = false ;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self",(char *) "prefix", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 arg2 = wxString_in_helper(obj1);
31380 if (arg2 == NULL) SWIG_fail;
31381 temp2 = true;
31382 }
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31386
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 Py_INCREF(Py_None); resultobj = Py_None;
31391 {
31392 if (temp2)
31393 delete arg2;
31394 }
31395 return resultobj;
31396 fail:
31397 {
31398 if (temp2)
31399 delete arg2;
31400 }
31401 return NULL;
31402 }
31403
31404
31405 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31406 PyObject *resultobj;
31407 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31408 wxString result;
31409 PyObject * obj0 = 0 ;
31410 char *kwnames[] = {
31411 (char *) "self", NULL
31412 };
31413
31414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31416 if (SWIG_arg_fail(1)) SWIG_fail;
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 result = wxStandardPaths_GetInstallPrefix(arg1);
31420
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 {
31425 #if wxUSE_UNICODE
31426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31427 #else
31428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31429 #endif
31430 }
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31438 PyObject *obj;
31439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31440 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31441 Py_INCREF(obj);
31442 return Py_BuildValue((char *)"");
31443 }
31444 static PyMethodDef SwigMethods[] = {
31445 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31452 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31459 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31523 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31531 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31549 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31552 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31555 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31558 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31564 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31578 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31584 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31593 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31607 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31610 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31611 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31614 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31641 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31643 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31645 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31654 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31660 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31674 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31678 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31681 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31698 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31706 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31753 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31771 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31781 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31797 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31813 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31827 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31837 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31880 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31883 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31886 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31890 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31983 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31984 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31985 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31986 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32003 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32082 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32090 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32091 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32096 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32105 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32112 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32115 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32118 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32123 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32126 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32130 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32133 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32137 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32138 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32142 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32146 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32150 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32160 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32173 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32181 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32189 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32203 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32207 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32225 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32239 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32250 { NULL, NULL, 0, NULL }
32251 };
32252
32253
32254 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32255
32256 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32257 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32258 }
32259 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32260 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32261 }
32262 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32263 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32264 }
32265 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32266 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32267 }
32268 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32269 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32270 }
32271 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32272 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32273 }
32274 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32275 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32276 }
32277 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32278 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32279 }
32280 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32282 }
32283 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32284 return (void *)((wxEvent *) ((wxPyEvent *) x));
32285 }
32286 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32287 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32288 }
32289 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32290 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32291 }
32292 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32293 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32294 }
32295 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32296 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32297 }
32298 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32299 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32300 }
32301 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32302 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32303 }
32304 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32305 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32306 }
32307 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32308 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32309 }
32310 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32311 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32312 }
32313 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32314 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32315 }
32316 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32318 }
32319 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32320 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32321 }
32322 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32323 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32324 }
32325 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32326 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32327 }
32328 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32329 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32330 }
32331 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32332 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32333 }
32334 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32335 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32336 }
32337 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32338 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32339 }
32340 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32341 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32342 }
32343 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32344 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32345 }
32346 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32347 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32348 }
32349 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32350 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32351 }
32352 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32353 return (void *)((wxEvent *) ((wxShowEvent *) x));
32354 }
32355 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32356 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32357 }
32358 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32360 }
32361 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32362 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32363 }
32364 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32365 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32366 }
32367 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32368 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32369 }
32370 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32371 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32372 }
32373 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32374 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32375 }
32376 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32377 return (void *)((wxConfigBase *) ((wxConfig *) x));
32378 }
32379 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32380 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32381 }
32382 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32383 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32384 }
32385 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32386 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32387 }
32388 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32389 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32390 }
32391 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32392 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32393 }
32394 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32395 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32396 }
32397 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32398 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32399 }
32400 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32401 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32402 }
32403 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32404 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32405 }
32406 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32407 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32408 }
32409 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32410 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32411 }
32412 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32413 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32414 }
32415 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32416 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32417 }
32418 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32419 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32420 }
32421 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32422 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32423 }
32424 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32425 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32426 }
32427 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32428 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32429 }
32430 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32431 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32432 }
32433 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32434 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32435 }
32436 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32437 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32438 }
32439 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32440 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32441 }
32442 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32443 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32444 }
32445 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32446 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32447 }
32448 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32449 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32450 }
32451 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32452 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32453 }
32454 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32455 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32456 }
32457 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32458 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32459 }
32460 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32461 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32462 }
32463 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32464 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32465 }
32466 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32467 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32468 }
32469 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32470 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32471 }
32472 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32473 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32474 }
32475 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32476 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32477 }
32478 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32480 }
32481 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32483 }
32484 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) ((wxSizerItem *) x));
32486 }
32487 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32489 }
32490 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32492 }
32493 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32495 }
32496 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32498 }
32499 static void *_p_wxSizerTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) ((wxSizer *) x));
32501 }
32502 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32504 }
32505 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) ((wxFileHistory *) x));
32507 }
32508 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32510 }
32511 static void *_p_wxEventTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) ((wxEvent *) x));
32513 }
32514 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32516 }
32517 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32519 }
32520 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32522 }
32523 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32525 }
32526 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32528 }
32529 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32531 }
32532 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32534 }
32535 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32537 }
32538 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32540 }
32541 static void *_p_wxControlTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32543 }
32544 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32546 }
32547 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32549 }
32550 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) ((wxFSFile *) x));
32552 }
32553 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) ((wxClipboard *) x));
32555 }
32556 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32558 }
32559 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32561 }
32562 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32564 }
32565 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32567 }
32568 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) ((wxToolTip *) x));
32570 }
32571 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) ((wxMenuItem *) x));
32573 }
32574 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32576 }
32577 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32579 }
32580 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32582 }
32583 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32585 }
32586 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32588 }
32589 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32591 }
32592 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32594 }
32595 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32597 }
32598 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32600 }
32601 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32603 }
32604 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32606 }
32607 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32609 }
32610 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32612 }
32613 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32615 }
32616 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32618 }
32619 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32621 }
32622 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32624 }
32625 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32627 }
32628 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32630 }
32631 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) ((wxImageHandler *) x));
32633 }
32634 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32636 }
32637 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) ((wxEvtHandler *) x));
32639 }
32640 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32642 }
32643 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32645 }
32646 static void *_p_wxImageTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) ((wxImage *) x));
32648 }
32649 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32651 }
32652 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) ((wxSystemOptions *) x));
32654 }
32655 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32657 }
32658 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32660 }
32661 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32663 }
32664 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32666 }
32667 static void *_p_wxWindowTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32669 }
32670 static void *_p_wxMenuTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32672 }
32673 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32675 }
32676 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32678 }
32679 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) ((wxFileSystem *) x));
32681 }
32682 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32684 }
32685 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32687 }
32688 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32690 }
32691 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32693 }
32694 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32696 }
32697 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32699 }
32700 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) ((wxBusyInfo *) x));
32702 }
32703 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32705 }
32706 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32708 }
32709 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32711 }
32712 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32714 }
32715 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32717 }
32718 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32720 }
32721 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32723 }
32724 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32726 }
32727 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32729 }
32730 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32732 }
32733 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32734 return (void *)((wxLog *) ((wxLogStderr *) x));
32735 }
32736 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32737 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32738 }
32739 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32740 return (void *)((wxLog *) ((wxLogWindow *) x));
32741 }
32742 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32743 return (void *)((wxLog *) ((wxLogChain *) x));
32744 }
32745 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32746 return (void *)((wxLog *) ((wxLogGui *) x));
32747 }
32748 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32749 return (void *)((wxLog *) ((wxPyLog *) x));
32750 }
32751 static void *_p_wxControlTo_p_wxWindow(void *x) {
32752 return (void *)((wxWindow *) ((wxControl *) x));
32753 }
32754 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32755 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32756 }
32757 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32758 return (void *)((wxWindow *) ((wxMenuBar *) x));
32759 }
32760 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32761 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32762 }
32763 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32764 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32765 }
32766 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}};
32767 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}};
32768 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803 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}};
32804 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}};
32805 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}};
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863
32864 static swig_type_info *swig_types_initial[] = {
32865 _swigt__p_wxLogChain,
32866 _swigt__p_wxMutexGuiLocker,
32867 _swigt__p_wxMetafile,
32868 _swigt__p_wxFileHistory,
32869 _swigt__p_wxLog,
32870 _swigt__p_wxMenu,
32871 _swigt__p_wxEvent,
32872 _swigt__p_wxDateTime__TimeZone,
32873 _swigt__p_wxConfigBase,
32874 _swigt__p_wxDisplay,
32875 _swigt__p_wxFileType,
32876 _swigt__p_wxLogGui,
32877 _swigt__p_wxFont,
32878 _swigt__p_wxDataFormat,
32879 _swigt__p_wxTimerEvent,
32880 _swigt__p_wxCaret,
32881 _swigt__ptrdiff_t,
32882 _swigt__std__ptrdiff_t,
32883 _swigt__p_int,
32884 _swigt__p_wxSize,
32885 _swigt__p_wxClipboard,
32886 _swigt__p_wxStopWatch,
32887 _swigt__p_wxDC,
32888 _swigt__p_wxClipboardLocker,
32889 _swigt__p_wxIcon,
32890 _swigt__p_wxLogStderr,
32891 _swigt__p_wxLogTextCtrl,
32892 _swigt__p_wxTextCtrl,
32893 _swigt__p_wxBusyCursor,
32894 _swigt__p_wxBitmapDataObject,
32895 _swigt__p_wxTextDataObject,
32896 _swigt__p_wxDataObject,
32897 _swigt__p_wxPyTextDataObject,
32898 _swigt__p_wxPyBitmapDataObject,
32899 _swigt__p_wxFileDataObject,
32900 _swigt__p_wxCustomDataObject,
32901 _swigt__p_wxURLDataObject,
32902 _swigt__p_wxMetafileDataObject,
32903 _swigt__p_wxSound,
32904 _swigt__p_wxTimerRunner,
32905 _swigt__p_wxLogWindow,
32906 _swigt__p_wxTimeSpan,
32907 _swigt__p_wxArrayString,
32908 _swigt__p_wxWindowDisabler,
32909 _swigt__p_form_ops_t,
32910 _swigt__p_wxToolTip,
32911 _swigt__p_wxDataObjectComposite,
32912 _swigt__p_wxSystemSettings,
32913 _swigt__p_wxFileConfig,
32914 _swigt__p_wxVideoMode,
32915 _swigt__p_wxDataObjectSimple,
32916 _swigt__p_wxPyDataObjectSimple,
32917 _swigt__p_wxDuplexMode,
32918 _swigt__p_wxEvtHandler,
32919 _swigt__p_wxRect,
32920 _swigt__p_char,
32921 _swigt__p_wxSingleInstanceChecker,
32922 _swigt__p_wxStandardPaths,
32923 _swigt__p_wxFileTypeInfo,
32924 _swigt__p_wxFrame,
32925 _swigt__p_wxTimer,
32926 _swigt__p_wxPaperSize,
32927 _swigt__p_wxMimeTypesManager,
32928 _swigt__p_wxPyArtProvider,
32929 _swigt__p_wxPyTipProvider,
32930 _swigt__p_wxTipProvider,
32931 _swigt__p_wxJoystick,
32932 _swigt__p_wxSystemOptions,
32933 _swigt__p_wxPoint,
32934 _swigt__p_wxJoystickEvent,
32935 _swigt__p_wxCursor,
32936 _swigt__p_wxObject,
32937 _swigt__p_wxOutputStream,
32938 _swigt__p_wxDateTime,
32939 _swigt__p_wxPyDropSource,
32940 _swigt__p_unsigned_long,
32941 _swigt__p_wxKillError,
32942 _swigt__p_wxWindow,
32943 _swigt__p_wxString,
32944 _swigt__p_wxPyProcess,
32945 _swigt__p_wxBitmap,
32946 _swigt__p_wxConfig,
32947 _swigt__unsigned_int,
32948 _swigt__p_unsigned_int,
32949 _swigt__p_unsigned_char,
32950 _swigt__p_wxChar,
32951 _swigt__p_wxBusyInfo,
32952 _swigt__p_wxPyDropTarget,
32953 _swigt__p_wxPyTextDropTarget,
32954 _swigt__p_wxPyFileDropTarget,
32955 _swigt__p_wxProcessEvent,
32956 _swigt__p_wxPyLog,
32957 _swigt__p_wxLogNull,
32958 _swigt__p_wxColour,
32959 _swigt__p_wxPyTimer,
32960 _swigt__p_wxConfigPathChanger,
32961 _swigt__p_wxDateSpan,
32962 0
32963 };
32964
32965
32966 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32967
32968 static swig_const_info swig_const_table[] = {
32969 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32970 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32971 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32972 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32973 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32974 {0, 0, 0, 0.0, 0, 0}};
32975
32976 #ifdef __cplusplus
32977 }
32978 #endif
32979
32980
32981 #ifdef __cplusplus
32982 extern "C" {
32983 #endif
32984
32985 /* Python-specific SWIG API */
32986 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32987 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32988 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32989
32990 /* -----------------------------------------------------------------------------
32991 * global variable support code.
32992 * ----------------------------------------------------------------------------- */
32993
32994 typedef struct swig_globalvar {
32995 char *name; /* Name of global variable */
32996 PyObject *(*get_attr)(); /* Return the current value */
32997 int (*set_attr)(PyObject *); /* Set the value */
32998 struct swig_globalvar *next;
32999 } swig_globalvar;
33000
33001 typedef struct swig_varlinkobject {
33002 PyObject_HEAD
33003 swig_globalvar *vars;
33004 } swig_varlinkobject;
33005
33006 static PyObject *
33007 swig_varlink_repr(swig_varlinkobject *v) {
33008 v = v;
33009 return PyString_FromString("<Swig global variables>");
33010 }
33011
33012 static int
33013 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33014 swig_globalvar *var;
33015 flags = flags;
33016 fprintf(fp,"Swig global variables { ");
33017 for (var = v->vars; var; var=var->next) {
33018 fprintf(fp,"%s", var->name);
33019 if (var->next) fprintf(fp,", ");
33020 }
33021 fprintf(fp," }\n");
33022 return 0;
33023 }
33024
33025 static PyObject *
33026 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33027 swig_globalvar *var = v->vars;
33028 while (var) {
33029 if (strcmp(var->name,n) == 0) {
33030 return (*var->get_attr)();
33031 }
33032 var = var->next;
33033 }
33034 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33035 return NULL;
33036 }
33037
33038 static int
33039 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33040 swig_globalvar *var = v->vars;
33041 while (var) {
33042 if (strcmp(var->name,n) == 0) {
33043 return (*var->set_attr)(p);
33044 }
33045 var = var->next;
33046 }
33047 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33048 return 1;
33049 }
33050
33051 static PyTypeObject varlinktype = {
33052 PyObject_HEAD_INIT(0)
33053 0, /* Number of items in variable part (ob_size) */
33054 (char *)"swigvarlink", /* Type name (tp_name) */
33055 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33056 0, /* Itemsize (tp_itemsize) */
33057 0, /* Deallocator (tp_dealloc) */
33058 (printfunc) swig_varlink_print, /* Print (tp_print) */
33059 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33060 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33061 0, /* tp_compare */
33062 (reprfunc) swig_varlink_repr, /* tp_repr */
33063 0, /* tp_as_number */
33064 0, /* tp_as_sequence */
33065 0, /* tp_as_mapping */
33066 0, /* tp_hash */
33067 0, /* tp_call */
33068 0, /* tp_str */
33069 0, /* tp_getattro */
33070 0, /* tp_setattro */
33071 0, /* tp_as_buffer */
33072 0, /* tp_flags */
33073 0, /* tp_doc */
33074 #if PY_VERSION_HEX >= 0x02000000
33075 0, /* tp_traverse */
33076 0, /* tp_clear */
33077 #endif
33078 #if PY_VERSION_HEX >= 0x02010000
33079 0, /* tp_richcompare */
33080 0, /* tp_weaklistoffset */
33081 #endif
33082 #if PY_VERSION_HEX >= 0x02020000
33083 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33084 #endif
33085 #if PY_VERSION_HEX >= 0x02030000
33086 0, /* tp_del */
33087 #endif
33088 #ifdef COUNT_ALLOCS
33089 0,0,0,0 /* tp_alloc -> tp_next */
33090 #endif
33091 };
33092
33093 /* Create a variable linking object for use later */
33094 static PyObject *
33095 SWIG_Python_newvarlink(void) {
33096 swig_varlinkobject *result = 0;
33097 result = PyMem_NEW(swig_varlinkobject,1);
33098 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33099 result->ob_type = &varlinktype;
33100 result->vars = 0;
33101 result->ob_refcnt = 0;
33102 Py_XINCREF((PyObject *) result);
33103 return ((PyObject*) result);
33104 }
33105
33106 static void
33107 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33108 swig_varlinkobject *v;
33109 swig_globalvar *gv;
33110 v= (swig_varlinkobject *) p;
33111 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33112 gv->name = (char *) malloc(strlen(name)+1);
33113 strcpy(gv->name,name);
33114 gv->get_attr = get_attr;
33115 gv->set_attr = set_attr;
33116 gv->next = v->vars;
33117 v->vars = gv;
33118 }
33119
33120 /* -----------------------------------------------------------------------------
33121 * constants/methods manipulation
33122 * ----------------------------------------------------------------------------- */
33123
33124 /* Install Constants */
33125 static void
33126 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33127 PyObject *obj = 0;
33128 size_t i;
33129 for (i = 0; constants[i].type; i++) {
33130 switch(constants[i].type) {
33131 case SWIG_PY_INT:
33132 obj = PyInt_FromLong(constants[i].lvalue);
33133 break;
33134 case SWIG_PY_FLOAT:
33135 obj = PyFloat_FromDouble(constants[i].dvalue);
33136 break;
33137 case SWIG_PY_STRING:
33138 if (constants[i].pvalue) {
33139 obj = PyString_FromString((char *) constants[i].pvalue);
33140 } else {
33141 Py_INCREF(Py_None);
33142 obj = Py_None;
33143 }
33144 break;
33145 case SWIG_PY_POINTER:
33146 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33147 break;
33148 case SWIG_PY_BINARY:
33149 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33150 break;
33151 default:
33152 obj = 0;
33153 break;
33154 }
33155 if (obj) {
33156 PyDict_SetItemString(d,constants[i].name,obj);
33157 Py_DECREF(obj);
33158 }
33159 }
33160 }
33161
33162 /* -----------------------------------------------------------------------------*/
33163 /* Fix SwigMethods to carry the callback ptrs when needed */
33164 /* -----------------------------------------------------------------------------*/
33165
33166 static void
33167 SWIG_Python_FixMethods(PyMethodDef *methods,
33168 swig_const_info *const_table,
33169 swig_type_info **types,
33170 swig_type_info **types_initial) {
33171 size_t i;
33172 for (i = 0; methods[i].ml_name; ++i) {
33173 char *c = methods[i].ml_doc;
33174 if (c && (c = strstr(c, "swig_ptr: "))) {
33175 int j;
33176 swig_const_info *ci = 0;
33177 char *name = c + 10;
33178 for (j = 0; const_table[j].type; j++) {
33179 if (strncmp(const_table[j].name, name,
33180 strlen(const_table[j].name)) == 0) {
33181 ci = &(const_table[j]);
33182 break;
33183 }
33184 }
33185 if (ci) {
33186 size_t shift = (ci->ptype) - types;
33187 swig_type_info *ty = types_initial[shift];
33188 size_t ldoc = (c - methods[i].ml_doc);
33189 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33190 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33191 char *buff = ndoc;
33192 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33193 strncpy(buff, methods[i].ml_doc, ldoc);
33194 buff += ldoc;
33195 strncpy(buff, "swig_ptr: ", 10);
33196 buff += 10;
33197 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33198 methods[i].ml_doc = ndoc;
33199 }
33200 }
33201 }
33202 }
33203
33204 /* -----------------------------------------------------------------------------*
33205 * Initialize type list
33206 * -----------------------------------------------------------------------------*/
33207
33208 #if PY_MAJOR_VERSION < 2
33209 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33210 is copied out of Python/modsupport.c in python version 2.3.4 */
33211 static int
33212 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33213 {
33214 PyObject *dict;
33215 if (!PyModule_Check(m)) {
33216 PyErr_SetString(PyExc_TypeError,
33217 "PyModule_AddObject() needs module as first arg");
33218 return -1;
33219 }
33220 if (!o) {
33221 PyErr_SetString(PyExc_TypeError,
33222 "PyModule_AddObject() needs non-NULL value");
33223 return -1;
33224 }
33225
33226 dict = PyModule_GetDict(m);
33227 if (dict == NULL) {
33228 /* Internal error -- modules must have a dict! */
33229 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33230 PyModule_GetName(m));
33231 return -1;
33232 }
33233 if (PyDict_SetItemString(dict, name, o))
33234 return -1;
33235 Py_DECREF(o);
33236 return 0;
33237 }
33238 #endif
33239
33240 static swig_type_info **
33241 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33242 static PyMethodDef swig_empty_runtime_method_table[] = {
33243 {
33244 NULL, NULL, 0, NULL
33245 }
33246 };/* Sentinel */
33247
33248 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33249 swig_empty_runtime_method_table);
33250 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33251 if (pointer && module) {
33252 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33253 }
33254 return type_list_handle;
33255 }
33256
33257 static swig_type_info **
33258 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33259 swig_type_info **type_pointer;
33260
33261 /* first check if module already created */
33262 type_pointer = SWIG_Python_GetTypeListHandle();
33263 if (type_pointer) {
33264 return type_pointer;
33265 } else {
33266 /* create a new module and variable */
33267 return SWIG_Python_SetTypeListHandle(type_list_handle);
33268 }
33269 }
33270
33271 #ifdef __cplusplus
33272 }
33273 #endif
33274
33275 /* -----------------------------------------------------------------------------*
33276 * Partial Init method
33277 * -----------------------------------------------------------------------------*/
33278
33279 #ifdef SWIG_LINK_RUNTIME
33280 #ifdef __cplusplus
33281 extern "C"
33282 #endif
33283 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33284 #endif
33285
33286 #ifdef __cplusplus
33287 extern "C"
33288 #endif
33289 SWIGEXPORT(void) SWIG_init(void) {
33290 static PyObject *SWIG_globals = 0;
33291 static int typeinit = 0;
33292 PyObject *m, *d;
33293 int i;
33294 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33295
33296 /* Fix SwigMethods to carry the callback ptrs when needed */
33297 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33298
33299 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33300 d = PyModule_GetDict(m);
33301
33302 if (!typeinit) {
33303 #ifdef SWIG_LINK_RUNTIME
33304 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33305 #else
33306 # ifndef SWIG_STATIC_RUNTIME
33307 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33308 # endif
33309 #endif
33310 for (i = 0; swig_types_initial[i]; i++) {
33311 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33312 }
33313 typeinit = 1;
33314 }
33315 SWIG_InstallConstants(d,swig_const_table);
33316
33317 {
33318 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33589 }
33590 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33591 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33592 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33593 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33594 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33595 {
33596 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33606 }
33607 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33608
33609 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33610
33611 {
33612 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33643 }
33644 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33645 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33646 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33647 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33648 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33649 {
33650 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33741 }
33742 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33743 {
33744 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33757 }
33758
33759 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33760
33761 {
33762 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33781 }
33782 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33783 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33784 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33785 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33786 {
33787 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33809 }
33810 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33811 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33812 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33813 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33814 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33815 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33816 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33817 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33818 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33819 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33820 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33821 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33822 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33823 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33824 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33825 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33826 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33827 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33828 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33830 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33831 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33832 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33833 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33834 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33835 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33837 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33838 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33839 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33840 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33841 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33842 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33843 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33844 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33845 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33846 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33847 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33848 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33849 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33850 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33851 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33852 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33866
33867 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33868
33869 {
33870 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33895 }
33896 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33898 {
33899 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34362 }
34363 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34364 {
34365 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34402 }
34403 {
34404 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34405 }
34406 {
34407 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34423 }
34424 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34425 {
34426 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34460 }
34461
34462 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34463 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34464 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34465 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34466
34467 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34468 }
34469
wxWidgets (Impactor)