]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
src/common/wxchar.cpps/wxConvLocal/wxConvLibs/g as otherwise we may fail to convert...
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718 static void wxCaret_Destroy(wxCaret *self){
1719 delete self;
1720 }
1721
1722 #include <wx/snglinst.h>
1723
1724
1725 #ifdef __WXMSW__
1726 #include <wx/msw/private.h>
1727 #include <wx/dynload.h>
1728 #endif
1729
1730
1731
1732 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1733 #if 0
1734 , int method
1735 #endif
1736 )
1737 {
1738 #ifdef __WXMSW__
1739 #if 0
1740 switch (method)
1741 {
1742 case 1:
1743 // This one only partially works. Appears to be an undocumented
1744 // "standard" convention that not all widgets adhear to. For
1745 // example, for some widgets backgrounds or non-client areas may
1746 // not be painted.
1747 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1748 break;
1749
1750 case 2:
1751 #endif
1752 // This one works much better, nearly all widgets and their
1753 // children are captured correctly[**]. Prior to the big
1754 // background erase changes that Vadim did in 2004-2005 this
1755 // method failed badly on XP with Themes activated, most native
1756 // widgets draw only partially, if at all. Without themes it
1757 // worked just like on Win2k. After those changes this method
1758 // works very well.
1759 //
1760 // ** For example the radio buttons in a wxRadioBox are not its
1761 // children by default, but you can capture it via the panel
1762 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1763 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1764 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1765 PRF_ERASEBKGND | PRF_OWNED );
1766 return true;
1767 #if 0
1768 break;
1769
1770 case 3:
1771 // This one is only defined in the latest SDK and is only
1772 // available on XP. MSDN says it is similar to sending WM_PRINT
1773 // so I expect that it will work similar to the above. Since it
1774 // is avaialble only on XP, it can't be compiled like this and
1775 // will have to be loaded dynamically.
1776 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1777
1778 // fall through
1779
1780 case 4:
1781 // Use PrintWindow if available, or fallback to WM_PRINT
1782 // otherwise. Unfortunately using PrintWindow is even worse than
1783 // WM_PRINT. For most native widgets nothing is drawn to the dc
1784 // at all, with or without Themes.
1785 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1786 static bool s_triedToLoad = false;
1787 static PrintWindow_t pfnPrintWindow = NULL;
1788 if ( !s_triedToLoad )
1789 {
1790
1791 s_triedToLoad = true;
1792 wxDynamicLibrary dllUser32(_T("user32.dll"));
1793 if ( dllUser32.IsLoaded() )
1794 {
1795 wxLogNull nolog; // Don't report errors here
1796 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1797 }
1798 }
1799 if (pfnPrintWindow)
1800 {
1801 //printf("Using PrintWindow\n");
1802 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1803 }
1804 else
1805 {
1806 //printf("Using WM_PRINT\n");
1807 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1808 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1809 PRF_ERASEBKGND | PRF_OWNED );
1810 }
1811 }
1812 #endif // 0
1813 #else
1814 return false;
1815 #endif // __WXMSW__
1816 }
1817
1818
1819
1820 #include <wx/tipdlg.h>
1821
1822
1823 class wxPyTipProvider : public wxTipProvider {
1824 public:
1825 wxPyTipProvider(size_t currentTip)
1826 : wxTipProvider(currentTip) {}
1827
1828 DEC_PYCALLBACK_STRING__pure(GetTip);
1829 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1830 PYPRIVATE;
1831 };
1832
1833 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1834 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1835
1836
1837 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1838
1839 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1840
1841 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1842 : wxTimer(owner, id)
1843 {
1844 if (owner == NULL) SetOwner(this);
1845 }
1846
1847
1848 void wxPyTimer::Notify() {
1849 bool found;
1850 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1851 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1853 wxPyEndBlockThreads(blocked);
1854 if (! found)
1855 wxTimer::Notify();
1856 }
1857 void wxPyTimer::base_Notify() {
1858 wxTimer::Notify();
1859 }
1860
1861
1862
1863 SWIGINTERN PyObject *
1864 SWIG_FromCharPtr(const char* cptr)
1865 {
1866 if (cptr) {
1867 size_t size = strlen(cptr);
1868 if (size > INT_MAX) {
1869 return SWIG_NewPointerObj((char*)(cptr),
1870 SWIG_TypeQuery("char *"), 0);
1871 } else {
1872 if (size != 0) {
1873 return PyString_FromStringAndSize(cptr, size);
1874 } else {
1875 return PyString_FromString(cptr);
1876 }
1877 }
1878 }
1879 Py_INCREF(Py_None);
1880 return Py_None;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_CheckUnsignedLongInRange(unsigned long value,
1886 unsigned long max_value,
1887 const char *errmsg)
1888 {
1889 if (value > max_value) {
1890 if (errmsg) {
1891 PyErr_Format(PyExc_OverflowError,
1892 "value %lu is greater than '%s' minimum %lu",
1893 value, errmsg, max_value);
1894 }
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900
1901 #if UINT_MAX != ULONG_MAX
1902 SWIGINTERN int
1903 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1904 {
1905 const char* errmsg = val ? "unsigned int" : (char*)0;
1906 unsigned long v;
1907 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1908 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1909 if (val) *val = (unsigned int)(v);
1910 return 1;
1911 }
1912 } else {
1913 PyErr_Clear();
1914 }
1915 if (val) {
1916 SWIG_type_error(errmsg, obj);
1917 }
1918 return 0;
1919 }
1920 #else
1921 SWIGINTERNSHORT unsigned int
1922 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1923 {
1924 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1925 }
1926 #endif
1927
1928
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_As_unsigned_SS_int(PyObject* obj)
1931 {
1932 unsigned int v;
1933 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1934 /*
1935 this is needed to make valgrind/purify happier.
1936 */
1937 memset((void*)&v, 0, sizeof(unsigned int));
1938 }
1939 return v;
1940 }
1941
1942
1943 SWIGINTERNSHORT int
1944 SWIG_Check_unsigned_SS_int(PyObject* obj)
1945 {
1946 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1947 }
1948
1949 static wxString Log_TimeStamp(){
1950 wxString msg;
1951 wxLog::TimeStamp(&msg);
1952 return msg;
1953 }
1954 static void wxLog_Destroy(wxLog *self){ delete self; }
1955 // Make somce wrappers that double any % signs so they are 'escaped'
1956 void wxPyLogFatalError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogFatalError(m);
1961 }
1962
1963 void wxPyLogError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogError(m);
1968 }
1969
1970 void wxPyLogWarning(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogWarning(m);
1975 }
1976
1977 void wxPyLogMessage(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogMessage(m);
1982 }
1983
1984 void wxPyLogInfo(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogInfo(m);
1989 }
1990
1991 void wxPyLogDebug(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogDebug(m);
1996 }
1997
1998 void wxPyLogVerbose(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogVerbose(m);
2003 }
2004
2005 void wxPyLogStatus(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(m);
2010 }
2011
2012 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(pFrame, m);
2017 }
2018
2019 void wxPyLogSysError(const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogSysError(m);
2024 }
2025
2026 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogGeneric(level, m);
2031 }
2032
2033 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047
2048
2049 // A wxLog class that can be derived from in wxPython
2050 class wxPyLog : public wxLog {
2051 public:
2052 wxPyLog() : wxLog() {}
2053
2054 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2055 bool found;
2056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLog(level, szString, t);
2065 }
2066
2067 virtual void DoLogString(const wxChar *szString, time_t t) {
2068 bool found;
2069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLogString(szString, t);
2078 }
2079
2080 PYPRIVATE;
2081 };
2082
2083
2084
2085
2086 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2087
2088
2089 #include <wx/joystick.h>
2090
2091
2092 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2093 // A C++ stub class for wxJoystick for platforms that don't have it.
2094 class wxJoystick : public wxObject {
2095 public:
2096 wxJoystick(int joystick = wxJOYSTICK1) {
2097 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2098 PyErr_SetString(PyExc_NotImplementedError,
2099 "wxJoystick is not available on this platform.");
2100 wxPyEndBlockThreads(blocked);
2101 }
2102 wxPoint GetPosition() { return wxPoint(-1,-1); }
2103 int GetZPosition() { return -1; }
2104 int GetButtonState() { return -1; }
2105 int GetPOVPosition() { return -1; }
2106 int GetPOVCTSPosition() { return -1; }
2107 int GetRudderPosition() { return -1; }
2108 int GetUPosition() { return -1; }
2109 int GetVPosition() { return -1; }
2110 int GetMovementThreshold() { return -1; }
2111 void SetMovementThreshold(int threshold) {}
2112
2113 bool IsOk(void) { return false; }
2114 int GetNumberJoysticks() { return -1; }
2115 int GetManufacturerId() { return -1; }
2116 int GetProductId() { return -1; }
2117 wxString GetProductName() { return wxEmptyString; }
2118 int GetXMin() { return -1; }
2119 int GetYMin() { return -1; }
2120 int GetZMin() { return -1; }
2121 int GetXMax() { return -1; }
2122 int GetYMax() { return -1; }
2123 int GetZMax() { return -1; }
2124 int GetNumberButtons() { return -1; }
2125 int GetNumberAxes() { return -1; }
2126 int GetMaxButtons() { return -1; }
2127 int GetMaxAxes() { return -1; }
2128 int GetPollingMin() { return -1; }
2129 int GetPollingMax() { return -1; }
2130 int GetRudderMin() { return -1; }
2131 int GetRudderMax() { return -1; }
2132 int GetUMin() { return -1; }
2133 int GetUMax() { return -1; }
2134 int GetVMin() { return -1; }
2135 int GetVMax() { return -1; }
2136
2137 bool HasRudder() { return false; }
2138 bool HasZ() { return false; }
2139 bool HasU() { return false; }
2140 bool HasV() { return false; }
2141 bool HasPOV() { return false; }
2142 bool HasPOV4Dir() { return false; }
2143 bool HasPOVCTS() { return false; }
2144
2145 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2146 bool ReleaseCapture() { return false; }
2147 };
2148 #endif
2149
2150
2151 #include <wx/sound.h>
2152
2153
2154 #if !wxUSE_SOUND
2155 // A C++ stub class for wxWave for platforms that don't have it.
2156 class wxSound : public wxObject
2157 {
2158 public:
2159 wxSound() {
2160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(const wxString&/*, bool*/) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(int, const wxByte*) {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177
2178 ~wxSound() {};
2179
2180 bool Create(const wxString&/*, bool*/) { return false; }
2181 bool Create(int, const wxByte*) { return false; };
2182 bool IsOk() { return false; };
2183 bool Play(unsigned) const { return false; }
2184 static bool Play(const wxString&, unsigned) { return false; }
2185 static void Stop() {}
2186 };
2187
2188 #endif
2189
2190 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2191 if (fileName.Length() == 0)
2192 return new wxSound;
2193 else
2194 return new wxSound(fileName);
2195 }
2196 static wxSound *new_wxSound(PyObject *data){
2197 unsigned char* buffer; int size;
2198 wxSound *sound = NULL;
2199
2200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2201 if (!PyArg_Parse(data, "t#", &buffer, &size))
2202 goto done;
2203 sound = new wxSound(size, buffer);
2204 done:
2205 wxPyEndBlockThreads(blocked);
2206 return sound;
2207 }
2208 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2209 #ifndef __WXMAC__
2210 unsigned char* buffer;
2211 int size;
2212 bool rv = false;
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 if (!PyArg_Parse(data, "t#", &buffer, &size))
2216 goto done;
2217 rv = self->Create(size, buffer);
2218 done:
2219 wxPyEndBlockThreads(blocked);
2220 return rv;
2221 #else
2222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2223 PyErr_SetString(PyExc_NotImplementedError,
2224 "Create from data is not available on this platform.");
2225 wxPyEndBlockThreads(blocked);
2226 return false;
2227 #endif
2228 }
2229
2230 #include <wx/mimetype.h>
2231
2232 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2233 wxString str;
2234 if (self->GetMimeType(&str))
2235 return wx2PyString(str);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetMimeTypes(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetExtensions(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc))
2256 return new wxIcon(loc);
2257 else
2258 return NULL;
2259 }
2260 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc)) {
2263 wxString iconFile = loc.GetFileName();
2264 int iconIndex = -1;
2265
2266
2267
2268 // Make a tuple and put the values in it
2269 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2270 PyObject* tuple = PyTuple_New(3);
2271 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2272 wxT("wxIcon"), true));
2273 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2274 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2275 wxPyEndBlockThreads(blocked);
2276 return tuple;
2277 }
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetDescription(wxFileType *self){
2282 wxString str;
2283 if (self->GetDescription(&str))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxArrayString verbs;
2304 wxArrayString commands;
2305 if (self->GetAllCommands(&verbs, &commands,
2306 wxFileType::MessageParameters(filename, mimetype))) {
2307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2308 PyObject* tuple = PyTuple_New(2);
2309 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2310 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2311 wxPyEndBlockThreads(blocked);
2312 return tuple;
2313 }
2314 else
2315 RETURN_NONE();
2316 }
2317 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2318 return wxFileType::ExpandCommand(command,
2319 wxFileType::MessageParameters(filename, mimetype));
2320 }
2321 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2322 wxArrayString arr;
2323 self->EnumAllFileTypes(arr);
2324 return wxArrayString2PyList_helper(arr);
2325 }
2326
2327 #include <wx/artprov.h>
2328
2329 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2330 static const wxString wxPyART_MENU(wxART_MENU);
2331 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2332 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2333 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2334 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2335 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2336 static const wxString wxPyART_OTHER(wxART_OTHER);
2337 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2338 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2339 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2340 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2341 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2342 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2343 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2344 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2345 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2346 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2347 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2348 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2349 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2350 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2351 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2352 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2353 static const wxString wxPyART_PRINT(wxART_PRINT);
2354 static const wxString wxPyART_HELP(wxART_HELP);
2355 static const wxString wxPyART_TIP(wxART_TIP);
2356 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2357 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2358 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2359 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2360 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2361 static const wxString wxPyART_CDROM(wxART_CDROM);
2362 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2363 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2364 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2365 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2366 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2367 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2368 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2369 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2370 static const wxString wxPyART_ERROR(wxART_ERROR);
2371 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2372 static const wxString wxPyART_WARNING(wxART_WARNING);
2373 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2374 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2375 static const wxString wxPyART_COPY(wxART_COPY);
2376 static const wxString wxPyART_CUT(wxART_CUT);
2377 static const wxString wxPyART_PASTE(wxART_PASTE);
2378 static const wxString wxPyART_DELETE(wxART_DELETE);
2379 static const wxString wxPyART_UNDO(wxART_UNDO);
2380 static const wxString wxPyART_REDO(wxART_REDO);
2381 static const wxString wxPyART_QUIT(wxART_QUIT);
2382 static const wxString wxPyART_FIND(wxART_FIND);
2383 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2384 // Python aware wxArtProvider
2385 class wxPyArtProvider : public wxArtProvider {
2386 public:
2387
2388 virtual wxBitmap CreateBitmap(const wxArtID& id,
2389 const wxArtClient& client,
2390 const wxSize& size) {
2391 wxBitmap rval = wxNullBitmap;
2392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2393 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2394 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2395 PyObject* ro;
2396 wxBitmap* ptr;
2397 PyObject* s1, *s2;
2398 s1 = wx2PyString(id);
2399 s2 = wx2PyString(client);
2400 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2401 Py_DECREF(so);
2402 Py_DECREF(s1);
2403 Py_DECREF(s2);
2404 if (ro) {
2405 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2406 rval = *ptr;
2407 Py_DECREF(ro);
2408 }
2409 }
2410 wxPyEndBlockThreads(blocked);
2411 return rval;
2412 }
2413
2414 PYPRIVATE;
2415 };
2416
2417 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2418
2419
2420
2421 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2422 PyObject* ret = PyTuple_New(3);
2423 if (ret) {
2424 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2425 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2426 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2427 }
2428 return ret;
2429 }
2430
2431 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2432 bool cont;
2433 long index = 0;
2434 wxString value;
2435
2436 cont = self->GetFirstGroup(value, index);
2437 return __EnumerationHelper(cont, value, index);
2438 }
2439 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2440 bool cont;
2441 wxString value;
2442
2443 cont = self->GetNextGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2447 bool cont;
2448 long index = 0;
2449 wxString value;
2450
2451 cont = self->GetFirstEntry(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2455 bool cont;
2456 wxString value;
2457
2458 cont = self->GetNextEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2462 long rv;
2463 self->Read(key, &rv, defaultVal);
2464 return rv;
2465 }
2466
2467 SWIGINTERN int
2468 SWIG_AsVal_double(PyObject *obj, double* val)
2469 {
2470 if (PyNumber_Check(obj)) {
2471 if (val) *val = PyFloat_AsDouble(obj);
2472 return 1;
2473 }
2474 else {
2475 SWIG_type_error("number", obj);
2476 }
2477 return 0;
2478 }
2479
2480
2481 SWIGINTERNSHORT double
2482 SWIG_As_double(PyObject* obj)
2483 {
2484 double v;
2485 if (!SWIG_AsVal_double(obj, &v)) {
2486 /*
2487 this is needed to make valgrind/purify happier.
2488 */
2489 memset((void*)&v, 0, sizeof(double));
2490 }
2491 return v;
2492 }
2493
2494
2495 SWIGINTERNSHORT int
2496 SWIG_Check_double(PyObject* obj)
2497 {
2498 return SWIG_AsVal_double(obj, (double*)0);
2499 }
2500
2501 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2502 double rv;
2503 self->Read(key, &rv, defaultVal);
2504 return rv;
2505 }
2506
2507 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_double PyFloat_FromDouble
2509 /*@@*/
2510
2511 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2512 bool rv;
2513 self->Read(key, &rv, defaultVal);
2514 return rv;
2515 }
2516
2517 #include <wx/datetime.h>
2518
2519 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2520 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2521
2522 #define LOCAL_TZ wxDateTime::Local
2523
2524 static PyObject *DateTime_GetAmPmStrings(){
2525 wxString am;
2526 wxString pm;
2527 wxDateTime::GetAmPmStrings(&am, &pm);
2528 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2529 PyObject* tup = PyTuple_New(2);
2530 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2531 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2532 wxPyEndBlockThreads(blocked);
2533 return tup;
2534 }
2535
2536 #if UINT_MAX < LONG_MAX
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_long
2539 /*@@*/
2540 #else
2541 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2542 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2543 /*@@*/
2544 #endif
2545
2546 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2547 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2548 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2549 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2550 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2551 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2552 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2553 return (*self < *other);
2554 }
2555 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2556 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2557 return (*self <= *other);
2558 }
2559 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2561 return (*self > *other);
2562 }
2563 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2565 return (*self >= *other);
2566 }
2567 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2569 return (*self == *other);
2570 }
2571 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2573 return (*self != *other);
2574 }
2575 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2576 const wxChar* rv;
2577 const wxChar* _date = date;
2578 rv = self->ParseRfc822Date(_date);
2579 if (rv == NULL) return -1;
2580 return rv - _date;
2581 }
2582 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2583 const wxChar* rv;
2584 const wxChar* _date = date;
2585 rv = self->ParseFormat(_date, format, dateDef);
2586 if (rv == NULL) return -1;
2587 return rv - _date;
2588 }
2589 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2590 const wxChar* rv;
2591 const wxChar* _datetime = datetime;
2592 rv = self->ParseDateTime(_datetime);
2593 if (rv == NULL) return -1;
2594 return rv - _datetime;
2595 }
2596 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2597 const wxChar* rv;
2598 const wxChar* _date = date;
2599 rv = self->ParseDate(_date);
2600 if (rv == NULL) return -1;
2601 return rv - _date;
2602 }
2603 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2604 const wxChar* rv;
2605 const wxChar* _time = time;
2606 rv = self->ParseTime(_time);
2607 if (rv == NULL) return -1;
2608 return rv - _time;
2609 }
2610 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2611 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2612 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2613 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2614 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2615 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2616 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2617 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2618 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2620 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2621 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2622 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2623 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2624 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2626
2627 #include <wx/dataobj.h>
2628
2629 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2630 size_t count = self->GetFormatCount(dir);
2631 wxDataFormat* formats = new wxDataFormat[count];
2632 self->GetAllFormats(formats, dir);
2633
2634 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2635 PyObject* list = PyList_New(count);
2636 for (size_t i=0; i<count; i++) {
2637 wxDataFormat* format = new wxDataFormat(formats[i]);
2638 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2639 PyList_Append(list, obj);
2640 Py_DECREF(obj);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 delete [] formats;
2644 return list;
2645 }
2646 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2647 PyObject* rval = NULL;
2648 size_t size = self->GetDataSize(format);
2649 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2650 if (size) {
2651 char* buf = new char[size];
2652 if (self->GetDataHere(format, buf))
2653 rval = PyString_FromStringAndSize(buf, size);
2654 delete [] buf;
2655 }
2656 if (! rval) {
2657 rval = Py_None;
2658 Py_INCREF(rval);
2659 }
2660 wxPyEndBlockThreads(blocked);
2661 return rval;
2662 }
2663 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2664 bool rval;
2665 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2666 if (PyString_Check(data)) {
2667 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2668 }
2669 else {
2670 // raise a TypeError if not a string
2671 PyErr_SetString(PyExc_TypeError, "String expected.");
2672 rval = false;
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2678 PyObject* rval = NULL;
2679 size_t size = self->GetDataSize();
2680 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2681 if (size) {
2682 char* buf = new char[size];
2683 if (self->GetDataHere(buf))
2684 rval = PyString_FromStringAndSize(buf, size);
2685 delete [] buf;
2686 }
2687 if (! rval) {
2688 rval = Py_None;
2689 Py_INCREF(rval);
2690 }
2691 wxPyEndBlockThreads(blocked);
2692 return rval;
2693 }
2694 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2695 bool rval;
2696 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2697 if (PyString_Check(data)) {
2698 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2699 }
2700 else {
2701 // raise a TypeError if not a string
2702 PyErr_SetString(PyExc_TypeError, "String expected.");
2703 rval = false;
2704 }
2705 wxPyEndBlockThreads(blocked);
2706 return rval;
2707 }
2708 // Create a new class for wxPython to use
2709 class wxPyDataObjectSimple : public wxDataObjectSimple {
2710 public:
2711 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2712 : wxDataObjectSimple(format) {}
2713
2714 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2715 bool GetDataHere(void *buf) const;
2716 bool SetData(size_t len, const void *buf) const;
2717 PYPRIVATE;
2718 };
2719
2720 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2721
2722 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2723 // We need to get the data for this object and write it to buf. I think
2724 // the best way to do this for wxPython is to have the Python method
2725 // return either a string or None and then act appropriately with the
2726 // C++ version.
2727
2728 bool rval = false;
2729 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2730 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2731 PyObject* ro;
2732 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2733 if (ro) {
2734 rval = (ro != Py_None && PyString_Check(ro));
2735 if (rval)
2736 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2737 Py_DECREF(ro);
2738 }
2739 }
2740 wxPyEndBlockThreads(blocked);
2741 return rval;
2742 }
2743
2744 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2745 // For this one we simply need to make a string from buf and len
2746 // and send it to the Python method.
2747 bool rval = false;
2748 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2749 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2750 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2751 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2752 Py_DECREF(data);
2753 }
2754 wxPyEndBlockThreads(blocked);
2755 return rval;
2756 }
2757
2758 // Create a new class for wxPython to use
2759 class wxPyTextDataObject : public wxTextDataObject {
2760 public:
2761 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2762 : wxTextDataObject(text) {}
2763
2764 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2765 DEC_PYCALLBACK_STRING__const(GetText);
2766 DEC_PYCALLBACK__STRING(SetText);
2767 PYPRIVATE;
2768 };
2769
2770 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2771 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2772 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2773
2774
2775 // Create a new class for wxPython to use
2776 class wxPyBitmapDataObject : public wxBitmapDataObject {
2777 public:
2778 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2779 : wxBitmapDataObject(bitmap) {}
2780
2781 wxBitmap GetBitmap() const;
2782 void SetBitmap(const wxBitmap& bitmap);
2783 PYPRIVATE;
2784 };
2785
2786 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2787 wxBitmap* rval = &wxNullBitmap;
2788 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2789 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2790 PyObject* ro;
2791 wxBitmap* ptr;
2792 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2793 if (ro) {
2794 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2795 rval = ptr;
2796 Py_DECREF(ro);
2797 }
2798 }
2799 wxPyEndBlockThreads(blocked);
2800 return *rval;
2801 }
2802
2803 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2804 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2805 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2806 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2807 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2808 Py_DECREF(bo);
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 }
2812
2813 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2814 return new wxCustomDataObject(wxDataFormat(formatName));
2815 }
2816 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2817 bool rval;
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2819 if (PyString_Check(data)) {
2820 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2821 }
2822 else {
2823 // raise a TypeError if not a string
2824 PyErr_SetString(PyExc_TypeError, "String expected.");
2825 rval = false;
2826 }
2827 wxPyEndBlockThreads(blocked);
2828 return rval;
2829 }
2830 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2831 PyObject* obj;
2832 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2833 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2834 wxPyEndBlockThreads(blocked);
2835 return obj;
2836 }
2837
2838 class wxMetafileDataObject : public wxDataObjectSimple
2839 {
2840 public:
2841 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2842 };
2843
2844
2845 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2846
2847
2848 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2849 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2850 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2851 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2852 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2853
2854
2855 class wxPyTextDropTarget : public wxTextDropTarget {
2856 public:
2857 wxPyTextDropTarget() {}
2858
2859 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2860
2861 DEC_PYCALLBACK__(OnLeave);
2862 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2863 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2865 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2866
2867 PYPRIVATE;
2868 };
2869
2870 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2871 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2872 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2873 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2875 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2876
2877
2878
2879 class wxPyFileDropTarget : public wxFileDropTarget {
2880 public:
2881 wxPyFileDropTarget() {}
2882
2883 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2884
2885 DEC_PYCALLBACK__(OnLeave);
2886 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2887 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2889 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2890
2891 PYPRIVATE;
2892 };
2893
2894 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2895 const wxArrayString& filenames) {
2896 bool rval = false;
2897 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2898 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2899 PyObject* list = wxArrayString2PyList_helper(filenames);
2900 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2901 Py_DECREF(list);
2902 }
2903 wxPyEndBlockThreads(blocked);
2904 return rval;
2905 }
2906
2907
2908
2909 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2910 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2911 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2913 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2914
2915
2916
2917
2918 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2919
2920 #include <wx/display.h>
2921
2922 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2923 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2924
2925 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2926 #if !wxUSE_DISPLAY
2927 #include <wx/dynarray.h>
2928 #include <wx/vidmode.h>
2929
2930 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2931 #include "wx/arrimpl.cpp"
2932 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2933 const wxVideoMode wxDefaultVideoMode;
2934
2935 class wxDisplay
2936 {
2937 public:
2938 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2939 ~wxDisplay() {}
2940
2941 static size_t GetCount()
2942 { wxPyRaiseNotImplemented(); return 0; }
2943
2944 static int GetFromPoint(const wxPoint& pt)
2945 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2946 static int GetFromWindow(wxWindow *window)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948
2949 virtual bool IsOk() const { return false; }
2950 virtual wxRect GetGeometry() const { wxRect r; return r; }
2951 virtual wxString GetName() const { return wxEmptyString; }
2952 bool IsPrimary() const { return false; }
2953
2954 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2955 { wxArrayVideoModes a; return a; }
2956
2957 virtual wxVideoMode GetCurrentMode() const
2958 { return wxDefaultVideoMode; }
2959
2960 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2961 { return false; }
2962
2963 void ResetMode() {}
2964 };
2965 #endif
2966
2967 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2968 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2969 PyObject* pyList = NULL;
2970 wxArrayVideoModes arr = self->GetModes(mode);
2971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2972 pyList = PyList_New(0);
2973 for (int i=0; i < arr.GetCount(); i++) {
2974 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2975 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2976 PyList_Append(pyList, pyObj);
2977 Py_DECREF(pyObj);
2978 }
2979 wxPyEndBlockThreads(blocked);
2980 return pyList;
2981 }
2982
2983 #include <wx/stdpaths.h>
2984
2985 static wxStandardPaths *StandardPaths_Get(){
2986 return (wxStandardPaths*) &wxStandardPaths::Get();
2987 }
2988 #ifdef __cplusplus
2989 extern "C" {
2990 #endif
2991 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2992 PyObject *resultobj;
2993 wxSystemColour arg1 ;
2994 wxColour result;
2995 PyObject * obj0 = 0 ;
2996 char *kwnames[] = {
2997 (char *) "index", NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3001 {
3002 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3003 if (SWIG_arg_fail(1)) SWIG_fail;
3004 }
3005 {
3006 if (!wxPyCheckForApp()) SWIG_fail;
3007 PyThreadState* __tstate = wxPyBeginAllowThreads();
3008 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3009
3010 wxPyEndAllowThreads(__tstate);
3011 if (PyErr_Occurred()) SWIG_fail;
3012 }
3013 {
3014 wxColour * resultptr;
3015 resultptr = new wxColour((wxColour &)(result));
3016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3017 }
3018 return resultobj;
3019 fail:
3020 return NULL;
3021 }
3022
3023
3024 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3025 PyObject *resultobj;
3026 wxSystemFont arg1 ;
3027 wxFont result;
3028 PyObject * obj0 = 0 ;
3029 char *kwnames[] = {
3030 (char *) "index", NULL
3031 };
3032
3033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3034 {
3035 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3036 if (SWIG_arg_fail(1)) SWIG_fail;
3037 }
3038 {
3039 if (!wxPyCheckForApp()) SWIG_fail;
3040 PyThreadState* __tstate = wxPyBeginAllowThreads();
3041 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3042
3043 wxPyEndAllowThreads(__tstate);
3044 if (PyErr_Occurred()) SWIG_fail;
3045 }
3046 {
3047 wxFont * resultptr;
3048 resultptr = new wxFont((wxFont &)(result));
3049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3058 PyObject *resultobj;
3059 wxSystemMetric arg1 ;
3060 wxWindow *arg2 = (wxWindow *) NULL ;
3061 int result;
3062 PyObject * obj0 = 0 ;
3063 PyObject * obj1 = 0 ;
3064 char *kwnames[] = {
3065 (char *) "index",(char *) "win", NULL
3066 };
3067
3068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3069 {
3070 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3071 if (SWIG_arg_fail(1)) SWIG_fail;
3072 }
3073 if (obj1) {
3074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3075 if (SWIG_arg_fail(2)) SWIG_fail;
3076 }
3077 {
3078 if (!wxPyCheckForApp()) SWIG_fail;
3079 PyThreadState* __tstate = wxPyBeginAllowThreads();
3080 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3081
3082 wxPyEndAllowThreads(__tstate);
3083 if (PyErr_Occurred()) SWIG_fail;
3084 }
3085 {
3086 resultobj = SWIG_From_int((int)(result));
3087 }
3088 return resultobj;
3089 fail:
3090 return NULL;
3091 }
3092
3093
3094 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3095 PyObject *resultobj;
3096 wxSystemFeature arg1 ;
3097 bool result;
3098 PyObject * obj0 = 0 ;
3099 char *kwnames[] = {
3100 (char *) "index", NULL
3101 };
3102
3103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3104 {
3105 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3106 if (SWIG_arg_fail(1)) SWIG_fail;
3107 }
3108 {
3109 if (!wxPyCheckForApp()) SWIG_fail;
3110 PyThreadState* __tstate = wxPyBeginAllowThreads();
3111 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3112
3113 wxPyEndAllowThreads(__tstate);
3114 if (PyErr_Occurred()) SWIG_fail;
3115 }
3116 {
3117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3118 }
3119 return resultobj;
3120 fail:
3121 return NULL;
3122 }
3123
3124
3125 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3126 PyObject *resultobj;
3127 wxSystemScreenType result;
3128 char *kwnames[] = {
3129 NULL
3130 };
3131
3132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3133 {
3134 if (!wxPyCheckForApp()) SWIG_fail;
3135 PyThreadState* __tstate = wxPyBeginAllowThreads();
3136 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3137
3138 wxPyEndAllowThreads(__tstate);
3139 if (PyErr_Occurred()) SWIG_fail;
3140 }
3141 resultobj = SWIG_From_int((result));
3142 return resultobj;
3143 fail:
3144 return NULL;
3145 }
3146
3147
3148 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3149 PyObject *resultobj;
3150 wxSystemScreenType arg1 ;
3151 PyObject * obj0 = 0 ;
3152 char *kwnames[] = {
3153 (char *) "screen", NULL
3154 };
3155
3156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3157 {
3158 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3159 if (SWIG_arg_fail(1)) SWIG_fail;
3160 }
3161 {
3162 if (!wxPyCheckForApp()) SWIG_fail;
3163 PyThreadState* __tstate = wxPyBeginAllowThreads();
3164 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3165
3166 wxPyEndAllowThreads(__tstate);
3167 if (PyErr_Occurred()) SWIG_fail;
3168 }
3169 Py_INCREF(Py_None); resultobj = Py_None;
3170 return resultobj;
3171 fail:
3172 return NULL;
3173 }
3174
3175
3176 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3177 PyObject *obj;
3178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3179 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3180 Py_INCREF(obj);
3181 return Py_BuildValue((char *)"");
3182 }
3183 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3184 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3185 return 1;
3186 }
3187
3188
3189 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3190 PyObject *pyobj;
3191
3192 {
3193 #if wxUSE_UNICODE
3194 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3195 #else
3196 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3197 #endif
3198 }
3199 return pyobj;
3200 }
3201
3202
3203 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj;
3205 wxSystemOptions *result;
3206 char *kwnames[] = {
3207 NULL
3208 };
3209
3210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3211 {
3212 PyThreadState* __tstate = wxPyBeginAllowThreads();
3213 result = (wxSystemOptions *)new wxSystemOptions();
3214
3215 wxPyEndAllowThreads(__tstate);
3216 if (PyErr_Occurred()) SWIG_fail;
3217 }
3218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3219 return resultobj;
3220 fail:
3221 return NULL;
3222 }
3223
3224
3225 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxString *arg1 = 0 ;
3228 wxString *arg2 = 0 ;
3229 bool temp1 = false ;
3230 bool temp2 = false ;
3231 PyObject * obj0 = 0 ;
3232 PyObject * obj1 = 0 ;
3233 char *kwnames[] = {
3234 (char *) "name",(char *) "value", NULL
3235 };
3236
3237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3238 {
3239 arg1 = wxString_in_helper(obj0);
3240 if (arg1 == NULL) SWIG_fail;
3241 temp1 = true;
3242 }
3243 {
3244 arg2 = wxString_in_helper(obj1);
3245 if (arg2 == NULL) SWIG_fail;
3246 temp2 = true;
3247 }
3248 {
3249 PyThreadState* __tstate = wxPyBeginAllowThreads();
3250 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3251
3252 wxPyEndAllowThreads(__tstate);
3253 if (PyErr_Occurred()) SWIG_fail;
3254 }
3255 Py_INCREF(Py_None); resultobj = Py_None;
3256 {
3257 if (temp1)
3258 delete arg1;
3259 }
3260 {
3261 if (temp2)
3262 delete arg2;
3263 }
3264 return resultobj;
3265 fail:
3266 {
3267 if (temp1)
3268 delete arg1;
3269 }
3270 {
3271 if (temp2)
3272 delete arg2;
3273 }
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxString *arg1 = 0 ;
3281 int arg2 ;
3282 bool temp1 = false ;
3283 PyObject * obj0 = 0 ;
3284 PyObject * obj1 = 0 ;
3285 char *kwnames[] = {
3286 (char *) "name",(char *) "value", NULL
3287 };
3288
3289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3290 {
3291 arg1 = wxString_in_helper(obj0);
3292 if (arg1 == NULL) SWIG_fail;
3293 temp1 = true;
3294 }
3295 {
3296 arg2 = (int)(SWIG_As_int(obj1));
3297 if (SWIG_arg_fail(2)) SWIG_fail;
3298 }
3299 {
3300 PyThreadState* __tstate = wxPyBeginAllowThreads();
3301 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3302
3303 wxPyEndAllowThreads(__tstate);
3304 if (PyErr_Occurred()) SWIG_fail;
3305 }
3306 Py_INCREF(Py_None); resultobj = Py_None;
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return resultobj;
3312 fail:
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj;
3323 wxString *arg1 = 0 ;
3324 wxString result;
3325 bool temp1 = false ;
3326 PyObject * obj0 = 0 ;
3327 char *kwnames[] = {
3328 (char *) "name", NULL
3329 };
3330
3331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3332 {
3333 arg1 = wxString_in_helper(obj0);
3334 if (arg1 == NULL) SWIG_fail;
3335 temp1 = true;
3336 }
3337 {
3338 PyThreadState* __tstate = wxPyBeginAllowThreads();
3339 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3340
3341 wxPyEndAllowThreads(__tstate);
3342 if (PyErr_Occurred()) SWIG_fail;
3343 }
3344 {
3345 #if wxUSE_UNICODE
3346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3347 #else
3348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3349 #endif
3350 }
3351 {
3352 if (temp1)
3353 delete arg1;
3354 }
3355 return resultobj;
3356 fail:
3357 {
3358 if (temp1)
3359 delete arg1;
3360 }
3361 return NULL;
3362 }
3363
3364
3365 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3366 PyObject *resultobj;
3367 wxString *arg1 = 0 ;
3368 int result;
3369 bool temp1 = false ;
3370 PyObject * obj0 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "name", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3376 {
3377 arg1 = wxString_in_helper(obj0);
3378 if (arg1 == NULL) SWIG_fail;
3379 temp1 = true;
3380 }
3381 {
3382 PyThreadState* __tstate = wxPyBeginAllowThreads();
3383 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3384
3385 wxPyEndAllowThreads(__tstate);
3386 if (PyErr_Occurred()) SWIG_fail;
3387 }
3388 {
3389 resultobj = SWIG_From_int((int)(result));
3390 }
3391 {
3392 if (temp1)
3393 delete arg1;
3394 }
3395 return resultobj;
3396 fail:
3397 {
3398 if (temp1)
3399 delete arg1;
3400 }
3401 return NULL;
3402 }
3403
3404
3405 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3406 PyObject *resultobj;
3407 wxString *arg1 = 0 ;
3408 bool result;
3409 bool temp1 = false ;
3410 PyObject * obj0 = 0 ;
3411 char *kwnames[] = {
3412 (char *) "name", NULL
3413 };
3414
3415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3416 {
3417 arg1 = wxString_in_helper(obj0);
3418 if (arg1 == NULL) SWIG_fail;
3419 temp1 = true;
3420 }
3421 {
3422 PyThreadState* __tstate = wxPyBeginAllowThreads();
3423 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3424
3425 wxPyEndAllowThreads(__tstate);
3426 if (PyErr_Occurred()) SWIG_fail;
3427 }
3428 {
3429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3430 }
3431 {
3432 if (temp1)
3433 delete arg1;
3434 }
3435 return resultobj;
3436 fail:
3437 {
3438 if (temp1)
3439 delete arg1;
3440 }
3441 return NULL;
3442 }
3443
3444
3445 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3446 PyObject *obj;
3447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3448 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3449 Py_INCREF(obj);
3450 return Py_BuildValue((char *)"");
3451 }
3452 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3453 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3454 return 1;
3455 }
3456
3457
3458 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3459 PyObject *pyobj;
3460
3461 {
3462 #if wxUSE_UNICODE
3463 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3464 #else
3465 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3466 #endif
3467 }
3468 return pyobj;
3469 }
3470
3471
3472 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3473 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3474 return 1;
3475 }
3476
3477
3478 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3479 PyObject *pyobj;
3480
3481 {
3482 #if wxUSE_UNICODE
3483 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3484 #else
3485 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3486 #endif
3487 }
3488 return pyobj;
3489 }
3490
3491
3492 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3493 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3494 return 1;
3495 }
3496
3497
3498 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3499 PyObject *pyobj;
3500
3501 {
3502 #if wxUSE_UNICODE
3503 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3504 #else
3505 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3506 #endif
3507 }
3508 return pyobj;
3509 }
3510
3511
3512 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3513 PyObject *resultobj;
3514 long result;
3515 char *kwnames[] = {
3516 NULL
3517 };
3518
3519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (long)wxNewId();
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = SWIG_From_long((long)(result));
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 long arg1 ;
3539 PyObject * obj0 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "id", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3545 {
3546 arg1 = (long)(SWIG_As_long(obj0));
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 }
3549 {
3550 PyThreadState* __tstate = wxPyBeginAllowThreads();
3551 wxRegisterId(arg1);
3552
3553 wxPyEndAllowThreads(__tstate);
3554 if (PyErr_Occurred()) SWIG_fail;
3555 }
3556 Py_INCREF(Py_None); resultobj = Py_None;
3557 return resultobj;
3558 fail:
3559 return NULL;
3560 }
3561
3562
3563 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3564 PyObject *resultobj;
3565 long result;
3566 char *kwnames[] = {
3567 NULL
3568 };
3569
3570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3571 {
3572 PyThreadState* __tstate = wxPyBeginAllowThreads();
3573 result = (long)wxGetCurrentId();
3574
3575 wxPyEndAllowThreads(__tstate);
3576 if (PyErr_Occurred()) SWIG_fail;
3577 }
3578 {
3579 resultobj = SWIG_From_long((long)(result));
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj;
3589 int arg1 ;
3590 bool result;
3591 PyObject * obj0 = 0 ;
3592 char *kwnames[] = {
3593 (char *) "id", NULL
3594 };
3595
3596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3597 {
3598 arg1 = (int)(SWIG_As_int(obj0));
3599 if (SWIG_arg_fail(1)) SWIG_fail;
3600 }
3601 {
3602 PyThreadState* __tstate = wxPyBeginAllowThreads();
3603 result = (bool)wxIsStockID(arg1);
3604
3605 wxPyEndAllowThreads(__tstate);
3606 if (PyErr_Occurred()) SWIG_fail;
3607 }
3608 {
3609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3610 }
3611 return resultobj;
3612 fail:
3613 return NULL;
3614 }
3615
3616
3617 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3618 PyObject *resultobj;
3619 int arg1 ;
3620 wxString *arg2 = 0 ;
3621 bool result;
3622 bool temp2 = false ;
3623 PyObject * obj0 = 0 ;
3624 PyObject * obj1 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "id",(char *) "label", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3630 {
3631 arg1 = (int)(SWIG_As_int(obj0));
3632 if (SWIG_arg_fail(1)) SWIG_fail;
3633 }
3634 {
3635 arg2 = wxString_in_helper(obj1);
3636 if (arg2 == NULL) SWIG_fail;
3637 temp2 = true;
3638 }
3639 {
3640 PyThreadState* __tstate = wxPyBeginAllowThreads();
3641 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3642
3643 wxPyEndAllowThreads(__tstate);
3644 if (PyErr_Occurred()) SWIG_fail;
3645 }
3646 {
3647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3648 }
3649 {
3650 if (temp2)
3651 delete arg2;
3652 }
3653 return resultobj;
3654 fail:
3655 {
3656 if (temp2)
3657 delete arg2;
3658 }
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 int arg1 ;
3666 bool arg2 = (bool) true ;
3667 wxString arg3 = (wxString) wxPyEmptyString ;
3668 wxString result;
3669 PyObject * obj0 = 0 ;
3670 PyObject * obj1 = 0 ;
3671 PyObject * obj2 = 0 ;
3672 char *kwnames[] = {
3673 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3674 };
3675
3676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3677 {
3678 arg1 = (int)(SWIG_As_int(obj0));
3679 if (SWIG_arg_fail(1)) SWIG_fail;
3680 }
3681 if (obj1) {
3682 {
3683 arg2 = (bool)(SWIG_As_bool(obj1));
3684 if (SWIG_arg_fail(2)) SWIG_fail;
3685 }
3686 }
3687 if (obj2) {
3688 {
3689 wxString* sptr = wxString_in_helper(obj2);
3690 if (sptr == NULL) SWIG_fail;
3691 arg3 = *sptr;
3692 delete sptr;
3693 }
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 result = wxGetStockLabel(arg1,arg2,arg3);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 {
3703 #if wxUSE_UNICODE
3704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3705 #else
3706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3707 #endif
3708 }
3709 return resultobj;
3710 fail:
3711 return NULL;
3712 }
3713
3714
3715 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3716 PyObject *resultobj;
3717 char *kwnames[] = {
3718 NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3722 {
3723 if (!wxPyCheckForApp()) SWIG_fail;
3724 PyThreadState* __tstate = wxPyBeginAllowThreads();
3725 wxBell();
3726
3727 wxPyEndAllowThreads(__tstate);
3728 if (PyErr_Occurred()) SWIG_fail;
3729 }
3730 Py_INCREF(Py_None); resultobj = Py_None;
3731 return resultobj;
3732 fail:
3733 return NULL;
3734 }
3735
3736
3737 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3738 PyObject *resultobj;
3739 char *kwnames[] = {
3740 NULL
3741 };
3742
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3744 {
3745 if (!wxPyCheckForApp()) SWIG_fail;
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 wxEndBusyCursor();
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 Py_INCREF(Py_None); resultobj = Py_None;
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 bool arg1 = (bool) true ;
3762 long result;
3763 PyObject * obj0 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "resetTimer", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3769 if (obj0) {
3770 {
3771 arg1 = (bool)(SWIG_As_bool(obj0));
3772 if (SWIG_arg_fail(1)) SWIG_fail;
3773 }
3774 }
3775 {
3776 PyThreadState* __tstate = wxPyBeginAllowThreads();
3777 result = (long)wxGetElapsedTime(arg1);
3778
3779 wxPyEndAllowThreads(__tstate);
3780 if (PyErr_Occurred()) SWIG_fail;
3781 }
3782 {
3783 resultobj = SWIG_From_long((long)(result));
3784 }
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 int *arg1 = (int *) 0 ;
3794 int *arg2 = (int *) 0 ;
3795 int temp1 ;
3796 int res1 = 0 ;
3797 int temp2 ;
3798 int res2 = 0 ;
3799 char *kwnames[] = {
3800 NULL
3801 };
3802
3803 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3804 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3806 {
3807 if (!wxPyCheckForApp()) SWIG_fail;
3808 PyThreadState* __tstate = wxPyBeginAllowThreads();
3809 wxGetMousePosition(arg1,arg2);
3810
3811 wxPyEndAllowThreads(__tstate);
3812 if (PyErr_Occurred()) SWIG_fail;
3813 }
3814 Py_INCREF(Py_None); resultobj = Py_None;
3815 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3816 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3817 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3818 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3819 return resultobj;
3820 fail:
3821 return NULL;
3822 }
3823
3824
3825 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3826 PyObject *resultobj;
3827 bool result;
3828 char *kwnames[] = {
3829 NULL
3830 };
3831
3832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 result = (bool)wxIsBusy();
3836
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 {
3841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3842 }
3843 return resultobj;
3844 fail:
3845 return NULL;
3846 }
3847
3848
3849 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3850 PyObject *resultobj;
3851 wxString result;
3852 char *kwnames[] = {
3853 NULL
3854 };
3855
3856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3857 {
3858 PyThreadState* __tstate = wxPyBeginAllowThreads();
3859 result = wxNow();
3860
3861 wxPyEndAllowThreads(__tstate);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 {
3865 #if wxUSE_UNICODE
3866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3867 #else
3868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3869 #endif
3870 }
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 wxString const &arg1_defvalue = wxPyEmptyString ;
3880 wxString *arg1 = (wxString *) &arg1_defvalue ;
3881 bool result;
3882 bool temp1 = false ;
3883 PyObject * obj0 = 0 ;
3884 char *kwnames[] = {
3885 (char *) "command", NULL
3886 };
3887
3888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3889 if (obj0) {
3890 {
3891 arg1 = wxString_in_helper(obj0);
3892 if (arg1 == NULL) SWIG_fail;
3893 temp1 = true;
3894 }
3895 }
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 result = (bool)wxShell((wxString const &)*arg1);
3899
3900 wxPyEndAllowThreads(__tstate);
3901 if (PyErr_Occurred()) SWIG_fail;
3902 }
3903 {
3904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3905 }
3906 {
3907 if (temp1)
3908 delete arg1;
3909 }
3910 return resultobj;
3911 fail:
3912 {
3913 if (temp1)
3914 delete arg1;
3915 }
3916 return NULL;
3917 }
3918
3919
3920 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj;
3922 char *kwnames[] = {
3923 NULL
3924 };
3925
3926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3927 {
3928 PyThreadState* __tstate = wxPyBeginAllowThreads();
3929 wxStartTimer();
3930
3931 wxPyEndAllowThreads(__tstate);
3932 if (PyErr_Occurred()) SWIG_fail;
3933 }
3934 Py_INCREF(Py_None); resultobj = Py_None;
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 int *arg1 = (int *) 0 ;
3944 int *arg2 = (int *) 0 ;
3945 int result;
3946 int temp1 ;
3947 int res1 = 0 ;
3948 int temp2 ;
3949 int res2 = 0 ;
3950 char *kwnames[] = {
3951 NULL
3952 };
3953
3954 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3955 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3957 {
3958 PyThreadState* __tstate = wxPyBeginAllowThreads();
3959 result = (int)wxGetOsVersion(arg1,arg2);
3960
3961 wxPyEndAllowThreads(__tstate);
3962 if (PyErr_Occurred()) SWIG_fail;
3963 }
3964 {
3965 resultobj = SWIG_From_int((int)(result));
3966 }
3967 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3968 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3969 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3970 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3971 return resultobj;
3972 fail:
3973 return NULL;
3974 }
3975
3976
3977 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3978 PyObject *resultobj;
3979 wxString result;
3980 char *kwnames[] = {
3981 NULL
3982 };
3983
3984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3985 {
3986 PyThreadState* __tstate = wxPyBeginAllowThreads();
3987 result = wxGetOsDescription();
3988
3989 wxPyEndAllowThreads(__tstate);
3990 if (PyErr_Occurred()) SWIG_fail;
3991 }
3992 {
3993 #if wxUSE_UNICODE
3994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3995 #else
3996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3997 #endif
3998 }
3999 return resultobj;
4000 fail:
4001 return NULL;
4002 }
4003
4004
4005 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4006 PyObject *resultobj;
4007 long result;
4008 char *kwnames[] = {
4009 NULL
4010 };
4011
4012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4013 {
4014 PyThreadState* __tstate = wxPyBeginAllowThreads();
4015 result = (long)wxGetFreeMemory();
4016
4017 wxPyEndAllowThreads(__tstate);
4018 if (PyErr_Occurred()) SWIG_fail;
4019 }
4020 {
4021 resultobj = SWIG_From_long((long)(result));
4022 }
4023 return resultobj;
4024 fail:
4025 return NULL;
4026 }
4027
4028
4029 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj;
4031 wxShutdownFlags arg1 ;
4032 bool result;
4033 PyObject * obj0 = 0 ;
4034 char *kwnames[] = {
4035 (char *) "wFlags", NULL
4036 };
4037
4038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4039 {
4040 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4041 if (SWIG_arg_fail(1)) SWIG_fail;
4042 }
4043 {
4044 if (!wxPyCheckForApp()) SWIG_fail;
4045 PyThreadState* __tstate = wxPyBeginAllowThreads();
4046 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4047
4048 wxPyEndAllowThreads(__tstate);
4049 if (PyErr_Occurred()) SWIG_fail;
4050 }
4051 {
4052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4053 }
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj;
4062 int arg1 ;
4063 PyObject * obj0 = 0 ;
4064 char *kwnames[] = {
4065 (char *) "secs", NULL
4066 };
4067
4068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4069 {
4070 arg1 = (int)(SWIG_As_int(obj0));
4071 if (SWIG_arg_fail(1)) SWIG_fail;
4072 }
4073 {
4074 PyThreadState* __tstate = wxPyBeginAllowThreads();
4075 wxSleep(arg1);
4076
4077 wxPyEndAllowThreads(__tstate);
4078 if (PyErr_Occurred()) SWIG_fail;
4079 }
4080 Py_INCREF(Py_None); resultobj = Py_None;
4081 return resultobj;
4082 fail:
4083 return NULL;
4084 }
4085
4086
4087 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj;
4089 unsigned long arg1 ;
4090 PyObject * obj0 = 0 ;
4091 char *kwnames[] = {
4092 (char *) "milliseconds", NULL
4093 };
4094
4095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4096 {
4097 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 }
4100 {
4101 PyThreadState* __tstate = wxPyBeginAllowThreads();
4102 wxMilliSleep(arg1);
4103
4104 wxPyEndAllowThreads(__tstate);
4105 if (PyErr_Occurred()) SWIG_fail;
4106 }
4107 Py_INCREF(Py_None); resultobj = Py_None;
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj;
4116 unsigned long arg1 ;
4117 PyObject * obj0 = 0 ;
4118 char *kwnames[] = {
4119 (char *) "microseconds", NULL
4120 };
4121
4122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4123 {
4124 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4125 if (SWIG_arg_fail(1)) SWIG_fail;
4126 }
4127 {
4128 PyThreadState* __tstate = wxPyBeginAllowThreads();
4129 wxMicroSleep(arg1);
4130
4131 wxPyEndAllowThreads(__tstate);
4132 if (PyErr_Occurred()) SWIG_fail;
4133 }
4134 Py_INCREF(Py_None); resultobj = Py_None;
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 bool arg1 ;
4144 PyObject * obj0 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "enable", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4150 {
4151 arg1 = (bool)(SWIG_As_bool(obj0));
4152 if (SWIG_arg_fail(1)) SWIG_fail;
4153 }
4154 {
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 wxEnableTopLevelWindows(arg1);
4157
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 Py_INCREF(Py_None); resultobj = Py_None;
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4169 PyObject *resultobj;
4170 wxString *arg1 = 0 ;
4171 wxString result;
4172 bool temp1 = false ;
4173 PyObject * obj0 = 0 ;
4174 char *kwnames[] = {
4175 (char *) "in", NULL
4176 };
4177
4178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4179 {
4180 arg1 = wxString_in_helper(obj0);
4181 if (arg1 == NULL) SWIG_fail;
4182 temp1 = true;
4183 }
4184 {
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = wxStripMenuCodes((wxString const &)*arg1);
4187
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 {
4192 #if wxUSE_UNICODE
4193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4194 #else
4195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4196 #endif
4197 }
4198 {
4199 if (temp1)
4200 delete arg1;
4201 }
4202 return resultobj;
4203 fail:
4204 {
4205 if (temp1)
4206 delete arg1;
4207 }
4208 return NULL;
4209 }
4210
4211
4212 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj;
4214 wxString result;
4215 char *kwnames[] = {
4216 NULL
4217 };
4218
4219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4220 {
4221 PyThreadState* __tstate = wxPyBeginAllowThreads();
4222 result = wxGetEmailAddress();
4223
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 #if wxUSE_UNICODE
4229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4230 #else
4231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4232 #endif
4233 }
4234 return resultobj;
4235 fail:
4236 return NULL;
4237 }
4238
4239
4240 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4241 PyObject *resultobj;
4242 wxString result;
4243 char *kwnames[] = {
4244 NULL
4245 };
4246
4247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4248 {
4249 PyThreadState* __tstate = wxPyBeginAllowThreads();
4250 result = wxGetHostName();
4251
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 {
4256 #if wxUSE_UNICODE
4257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4258 #else
4259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4260 #endif
4261 }
4262 return resultobj;
4263 fail:
4264 return NULL;
4265 }
4266
4267
4268 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4269 PyObject *resultobj;
4270 wxString result;
4271 char *kwnames[] = {
4272 NULL
4273 };
4274
4275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4276 {
4277 PyThreadState* __tstate = wxPyBeginAllowThreads();
4278 result = wxGetFullHostName();
4279
4280 wxPyEndAllowThreads(__tstate);
4281 if (PyErr_Occurred()) SWIG_fail;
4282 }
4283 {
4284 #if wxUSE_UNICODE
4285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4286 #else
4287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4288 #endif
4289 }
4290 return resultobj;
4291 fail:
4292 return NULL;
4293 }
4294
4295
4296 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4297 PyObject *resultobj;
4298 wxString result;
4299 char *kwnames[] = {
4300 NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 result = wxGetUserId();
4307
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 {
4312 #if wxUSE_UNICODE
4313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4314 #else
4315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4316 #endif
4317 }
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj;
4326 wxString result;
4327 char *kwnames[] = {
4328 NULL
4329 };
4330
4331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4332 {
4333 PyThreadState* __tstate = wxPyBeginAllowThreads();
4334 result = wxGetUserName();
4335
4336 wxPyEndAllowThreads(__tstate);
4337 if (PyErr_Occurred()) SWIG_fail;
4338 }
4339 {
4340 #if wxUSE_UNICODE
4341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4342 #else
4343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4344 #endif
4345 }
4346 return resultobj;
4347 fail:
4348 return NULL;
4349 }
4350
4351
4352 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4353 PyObject *resultobj;
4354 wxString result;
4355 char *kwnames[] = {
4356 NULL
4357 };
4358
4359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4360 {
4361 PyThreadState* __tstate = wxPyBeginAllowThreads();
4362 result = wxGetHomeDir();
4363
4364 wxPyEndAllowThreads(__tstate);
4365 if (PyErr_Occurred()) SWIG_fail;
4366 }
4367 {
4368 #if wxUSE_UNICODE
4369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4370 #else
4371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4372 #endif
4373 }
4374 return resultobj;
4375 fail:
4376 return NULL;
4377 }
4378
4379
4380 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4381 PyObject *resultobj;
4382 wxString const &arg1_defvalue = wxPyEmptyString ;
4383 wxString *arg1 = (wxString *) &arg1_defvalue ;
4384 wxString result;
4385 bool temp1 = false ;
4386 PyObject * obj0 = 0 ;
4387 char *kwnames[] = {
4388 (char *) "user", NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4392 if (obj0) {
4393 {
4394 arg1 = wxString_in_helper(obj0);
4395 if (arg1 == NULL) SWIG_fail;
4396 temp1 = true;
4397 }
4398 }
4399 {
4400 PyThreadState* __tstate = wxPyBeginAllowThreads();
4401 result = wxGetUserHome((wxString const &)*arg1);
4402
4403 wxPyEndAllowThreads(__tstate);
4404 if (PyErr_Occurred()) SWIG_fail;
4405 }
4406 {
4407 #if wxUSE_UNICODE
4408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4409 #else
4410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4411 #endif
4412 }
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return resultobj;
4418 fail:
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj;
4429 unsigned long result;
4430 char *kwnames[] = {
4431 NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = (unsigned long)wxGetProcessId();
4438
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 {
4443 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4444 }
4445 return resultobj;
4446 fail:
4447 return NULL;
4448 }
4449
4450
4451 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4452 PyObject *resultobj;
4453 char *kwnames[] = {
4454 NULL
4455 };
4456
4457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4458 {
4459 PyThreadState* __tstate = wxPyBeginAllowThreads();
4460 wxTrap();
4461
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 Py_INCREF(Py_None); resultobj = Py_None;
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4475 wxString *arg1 = (wxString *) &arg1_defvalue ;
4476 wxString const &arg2_defvalue = wxPyEmptyString ;
4477 wxString *arg2 = (wxString *) &arg2_defvalue ;
4478 wxString const &arg3_defvalue = wxPyEmptyString ;
4479 wxString *arg3 = (wxString *) &arg3_defvalue ;
4480 wxString const &arg4_defvalue = wxPyEmptyString ;
4481 wxString *arg4 = (wxString *) &arg4_defvalue ;
4482 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4483 wxString *arg5 = (wxString *) &arg5_defvalue ;
4484 int arg6 = (int) 0 ;
4485 wxWindow *arg7 = (wxWindow *) NULL ;
4486 int arg8 = (int) -1 ;
4487 int arg9 = (int) -1 ;
4488 wxString result;
4489 bool temp1 = false ;
4490 bool temp2 = false ;
4491 bool temp3 = false ;
4492 bool temp4 = false ;
4493 bool temp5 = false ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 PyObject * obj2 = 0 ;
4497 PyObject * obj3 = 0 ;
4498 PyObject * obj4 = 0 ;
4499 PyObject * obj5 = 0 ;
4500 PyObject * obj6 = 0 ;
4501 PyObject * obj7 = 0 ;
4502 PyObject * obj8 = 0 ;
4503 char *kwnames[] = {
4504 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4505 };
4506
4507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4508 if (obj0) {
4509 {
4510 arg1 = wxString_in_helper(obj0);
4511 if (arg1 == NULL) SWIG_fail;
4512 temp1 = true;
4513 }
4514 }
4515 if (obj1) {
4516 {
4517 arg2 = wxString_in_helper(obj1);
4518 if (arg2 == NULL) SWIG_fail;
4519 temp2 = true;
4520 }
4521 }
4522 if (obj2) {
4523 {
4524 arg3 = wxString_in_helper(obj2);
4525 if (arg3 == NULL) SWIG_fail;
4526 temp3 = true;
4527 }
4528 }
4529 if (obj3) {
4530 {
4531 arg4 = wxString_in_helper(obj3);
4532 if (arg4 == NULL) SWIG_fail;
4533 temp4 = true;
4534 }
4535 }
4536 if (obj4) {
4537 {
4538 arg5 = wxString_in_helper(obj4);
4539 if (arg5 == NULL) SWIG_fail;
4540 temp5 = true;
4541 }
4542 }
4543 if (obj5) {
4544 {
4545 arg6 = (int)(SWIG_As_int(obj5));
4546 if (SWIG_arg_fail(6)) SWIG_fail;
4547 }
4548 }
4549 if (obj6) {
4550 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4551 if (SWIG_arg_fail(7)) SWIG_fail;
4552 }
4553 if (obj7) {
4554 {
4555 arg8 = (int)(SWIG_As_int(obj7));
4556 if (SWIG_arg_fail(8)) SWIG_fail;
4557 }
4558 }
4559 if (obj8) {
4560 {
4561 arg9 = (int)(SWIG_As_int(obj8));
4562 if (SWIG_arg_fail(9)) SWIG_fail;
4563 }
4564 }
4565 {
4566 if (!wxPyCheckForApp()) SWIG_fail;
4567 PyThreadState* __tstate = wxPyBeginAllowThreads();
4568 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4569
4570 wxPyEndAllowThreads(__tstate);
4571 if (PyErr_Occurred()) SWIG_fail;
4572 }
4573 {
4574 #if wxUSE_UNICODE
4575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4576 #else
4577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4578 #endif
4579 }
4580 {
4581 if (temp1)
4582 delete arg1;
4583 }
4584 {
4585 if (temp2)
4586 delete arg2;
4587 }
4588 {
4589 if (temp3)
4590 delete arg3;
4591 }
4592 {
4593 if (temp4)
4594 delete arg4;
4595 }
4596 {
4597 if (temp5)
4598 delete arg5;
4599 }
4600 return resultobj;
4601 fail:
4602 {
4603 if (temp1)
4604 delete arg1;
4605 }
4606 {
4607 if (temp2)
4608 delete arg2;
4609 }
4610 {
4611 if (temp3)
4612 delete arg3;
4613 }
4614 {
4615 if (temp4)
4616 delete arg4;
4617 }
4618 {
4619 if (temp5)
4620 delete arg5;
4621 }
4622 return NULL;
4623 }
4624
4625
4626 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj;
4628 wxString *arg1 = 0 ;
4629 wxString *arg2 = 0 ;
4630 wxString const &arg3_defvalue = wxPyEmptyString ;
4631 wxString *arg3 = (wxString *) &arg3_defvalue ;
4632 wxWindow *arg4 = (wxWindow *) NULL ;
4633 wxString result;
4634 bool temp1 = false ;
4635 bool temp2 = false ;
4636 bool temp3 = false ;
4637 PyObject * obj0 = 0 ;
4638 PyObject * obj1 = 0 ;
4639 PyObject * obj2 = 0 ;
4640 PyObject * obj3 = 0 ;
4641 char *kwnames[] = {
4642 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4643 };
4644
4645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4646 {
4647 arg1 = wxString_in_helper(obj0);
4648 if (arg1 == NULL) SWIG_fail;
4649 temp1 = true;
4650 }
4651 {
4652 arg2 = wxString_in_helper(obj1);
4653 if (arg2 == NULL) SWIG_fail;
4654 temp2 = true;
4655 }
4656 if (obj2) {
4657 {
4658 arg3 = wxString_in_helper(obj2);
4659 if (arg3 == NULL) SWIG_fail;
4660 temp3 = true;
4661 }
4662 }
4663 if (obj3) {
4664 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4665 if (SWIG_arg_fail(4)) SWIG_fail;
4666 }
4667 {
4668 if (!wxPyCheckForApp()) SWIG_fail;
4669 PyThreadState* __tstate = wxPyBeginAllowThreads();
4670 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4671
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 {
4676 #if wxUSE_UNICODE
4677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4678 #else
4679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4680 #endif
4681 }
4682 {
4683 if (temp1)
4684 delete arg1;
4685 }
4686 {
4687 if (temp2)
4688 delete arg2;
4689 }
4690 {
4691 if (temp3)
4692 delete arg3;
4693 }
4694 return resultobj;
4695 fail:
4696 {
4697 if (temp1)
4698 delete arg1;
4699 }
4700 {
4701 if (temp2)
4702 delete arg2;
4703 }
4704 {
4705 if (temp3)
4706 delete arg3;
4707 }
4708 return NULL;
4709 }
4710
4711
4712 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj;
4714 wxString *arg1 = 0 ;
4715 wxString *arg2 = 0 ;
4716 wxString const &arg3_defvalue = wxPyEmptyString ;
4717 wxString *arg3 = (wxString *) &arg3_defvalue ;
4718 wxWindow *arg4 = (wxWindow *) NULL ;
4719 wxString result;
4720 bool temp1 = false ;
4721 bool temp2 = false ;
4722 bool temp3 = false ;
4723 PyObject * obj0 = 0 ;
4724 PyObject * obj1 = 0 ;
4725 PyObject * obj2 = 0 ;
4726 PyObject * obj3 = 0 ;
4727 char *kwnames[] = {
4728 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4729 };
4730
4731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4732 {
4733 arg1 = wxString_in_helper(obj0);
4734 if (arg1 == NULL) SWIG_fail;
4735 temp1 = true;
4736 }
4737 {
4738 arg2 = wxString_in_helper(obj1);
4739 if (arg2 == NULL) SWIG_fail;
4740 temp2 = true;
4741 }
4742 if (obj2) {
4743 {
4744 arg3 = wxString_in_helper(obj2);
4745 if (arg3 == NULL) SWIG_fail;
4746 temp3 = true;
4747 }
4748 }
4749 if (obj3) {
4750 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4751 if (SWIG_arg_fail(4)) SWIG_fail;
4752 }
4753 {
4754 if (!wxPyCheckForApp()) SWIG_fail;
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4757
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 {
4762 #if wxUSE_UNICODE
4763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4764 #else
4765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4766 #endif
4767 }
4768 {
4769 if (temp1)
4770 delete arg1;
4771 }
4772 {
4773 if (temp2)
4774 delete arg2;
4775 }
4776 {
4777 if (temp3)
4778 delete arg3;
4779 }
4780 return resultobj;
4781 fail:
4782 {
4783 if (temp1)
4784 delete arg1;
4785 }
4786 {
4787 if (temp2)
4788 delete arg2;
4789 }
4790 {
4791 if (temp3)
4792 delete arg3;
4793 }
4794 return NULL;
4795 }
4796
4797
4798 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj;
4800 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4801 wxString *arg1 = (wxString *) &arg1_defvalue ;
4802 wxString const &arg2_defvalue = wxPyEmptyString ;
4803 wxString *arg2 = (wxString *) &arg2_defvalue ;
4804 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4805 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4806 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4807 wxWindow *arg5 = (wxWindow *) NULL ;
4808 wxString result;
4809 bool temp1 = false ;
4810 bool temp2 = false ;
4811 wxPoint temp4 ;
4812 PyObject * obj0 = 0 ;
4813 PyObject * obj1 = 0 ;
4814 PyObject * obj2 = 0 ;
4815 PyObject * obj3 = 0 ;
4816 PyObject * obj4 = 0 ;
4817 char *kwnames[] = {
4818 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4819 };
4820
4821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4822 if (obj0) {
4823 {
4824 arg1 = wxString_in_helper(obj0);
4825 if (arg1 == NULL) SWIG_fail;
4826 temp1 = true;
4827 }
4828 }
4829 if (obj1) {
4830 {
4831 arg2 = wxString_in_helper(obj1);
4832 if (arg2 == NULL) SWIG_fail;
4833 temp2 = true;
4834 }
4835 }
4836 if (obj2) {
4837 {
4838 arg3 = (long)(SWIG_As_long(obj2));
4839 if (SWIG_arg_fail(3)) SWIG_fail;
4840 }
4841 }
4842 if (obj3) {
4843 {
4844 arg4 = &temp4;
4845 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4846 }
4847 }
4848 if (obj4) {
4849 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4850 if (SWIG_arg_fail(5)) SWIG_fail;
4851 }
4852 {
4853 if (!wxPyCheckForApp()) SWIG_fail;
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4856
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 {
4861 #if wxUSE_UNICODE
4862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4863 #else
4864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4865 #endif
4866 }
4867 {
4868 if (temp1)
4869 delete arg1;
4870 }
4871 {
4872 if (temp2)
4873 delete arg2;
4874 }
4875 return resultobj;
4876 fail:
4877 {
4878 if (temp1)
4879 delete arg1;
4880 }
4881 {
4882 if (temp2)
4883 delete arg2;
4884 }
4885 return NULL;
4886 }
4887
4888
4889 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj;
4891 wxString *arg1 = 0 ;
4892 wxString const &arg2_defvalue = wxPyEmptyString ;
4893 wxString *arg2 = (wxString *) &arg2_defvalue ;
4894 wxString const &arg3_defvalue = wxPyEmptyString ;
4895 wxString *arg3 = (wxString *) &arg3_defvalue ;
4896 wxWindow *arg4 = (wxWindow *) NULL ;
4897 int arg5 = (int) -1 ;
4898 int arg6 = (int) -1 ;
4899 bool arg7 = (bool) true ;
4900 wxString result;
4901 bool temp1 = false ;
4902 bool temp2 = false ;
4903 bool temp3 = false ;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 PyObject * obj2 = 0 ;
4907 PyObject * obj3 = 0 ;
4908 PyObject * obj4 = 0 ;
4909 PyObject * obj5 = 0 ;
4910 PyObject * obj6 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4916 {
4917 arg1 = wxString_in_helper(obj0);
4918 if (arg1 == NULL) SWIG_fail;
4919 temp1 = true;
4920 }
4921 if (obj1) {
4922 {
4923 arg2 = wxString_in_helper(obj1);
4924 if (arg2 == NULL) SWIG_fail;
4925 temp2 = true;
4926 }
4927 }
4928 if (obj2) {
4929 {
4930 arg3 = wxString_in_helper(obj2);
4931 if (arg3 == NULL) SWIG_fail;
4932 temp3 = true;
4933 }
4934 }
4935 if (obj3) {
4936 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4937 if (SWIG_arg_fail(4)) SWIG_fail;
4938 }
4939 if (obj4) {
4940 {
4941 arg5 = (int)(SWIG_As_int(obj4));
4942 if (SWIG_arg_fail(5)) SWIG_fail;
4943 }
4944 }
4945 if (obj5) {
4946 {
4947 arg6 = (int)(SWIG_As_int(obj5));
4948 if (SWIG_arg_fail(6)) SWIG_fail;
4949 }
4950 }
4951 if (obj6) {
4952 {
4953 arg7 = (bool)(SWIG_As_bool(obj6));
4954 if (SWIG_arg_fail(7)) SWIG_fail;
4955 }
4956 }
4957 {
4958 if (!wxPyCheckForApp()) SWIG_fail;
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4961
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 {
4966 #if wxUSE_UNICODE
4967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4968 #else
4969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4970 #endif
4971 }
4972 {
4973 if (temp1)
4974 delete arg1;
4975 }
4976 {
4977 if (temp2)
4978 delete arg2;
4979 }
4980 {
4981 if (temp3)
4982 delete arg3;
4983 }
4984 return resultobj;
4985 fail:
4986 {
4987 if (temp1)
4988 delete arg1;
4989 }
4990 {
4991 if (temp2)
4992 delete arg2;
4993 }
4994 {
4995 if (temp3)
4996 delete arg3;
4997 }
4998 return NULL;
4999 }
5000
5001
5002 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj;
5004 wxString *arg1 = 0 ;
5005 wxString const &arg2_defvalue = wxPyEmptyString ;
5006 wxString *arg2 = (wxString *) &arg2_defvalue ;
5007 wxString const &arg3_defvalue = wxPyEmptyString ;
5008 wxString *arg3 = (wxString *) &arg3_defvalue ;
5009 wxWindow *arg4 = (wxWindow *) NULL ;
5010 wxString result;
5011 bool temp1 = false ;
5012 bool temp2 = false ;
5013 bool temp3 = false ;
5014 PyObject * obj0 = 0 ;
5015 PyObject * obj1 = 0 ;
5016 PyObject * obj2 = 0 ;
5017 PyObject * obj3 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5023 {
5024 arg1 = wxString_in_helper(obj0);
5025 if (arg1 == NULL) SWIG_fail;
5026 temp1 = true;
5027 }
5028 if (obj1) {
5029 {
5030 arg2 = wxString_in_helper(obj1);
5031 if (arg2 == NULL) SWIG_fail;
5032 temp2 = true;
5033 }
5034 }
5035 if (obj2) {
5036 {
5037 arg3 = wxString_in_helper(obj2);
5038 if (arg3 == NULL) SWIG_fail;
5039 temp3 = true;
5040 }
5041 }
5042 if (obj3) {
5043 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5044 if (SWIG_arg_fail(4)) SWIG_fail;
5045 }
5046 {
5047 if (!wxPyCheckForApp()) SWIG_fail;
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5050
5051 wxPyEndAllowThreads(__tstate);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 {
5055 #if wxUSE_UNICODE
5056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5057 #else
5058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5059 #endif
5060 }
5061 {
5062 if (temp1)
5063 delete arg1;
5064 }
5065 {
5066 if (temp2)
5067 delete arg2;
5068 }
5069 {
5070 if (temp3)
5071 delete arg3;
5072 }
5073 return resultobj;
5074 fail:
5075 {
5076 if (temp1)
5077 delete arg1;
5078 }
5079 {
5080 if (temp2)
5081 delete arg2;
5082 }
5083 {
5084 if (temp3)
5085 delete arg3;
5086 }
5087 return NULL;
5088 }
5089
5090
5091 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5092 PyObject *resultobj;
5093 wxString *arg1 = 0 ;
5094 wxString *arg2 = 0 ;
5095 int arg3 ;
5096 wxString *arg4 = (wxString *) 0 ;
5097 wxWindow *arg5 = (wxWindow *) NULL ;
5098 int arg6 = (int) -1 ;
5099 int arg7 = (int) -1 ;
5100 bool arg8 = (bool) true ;
5101 int arg9 = (int) 150 ;
5102 int arg10 = (int) 200 ;
5103 wxString result;
5104 bool temp1 = false ;
5105 bool temp2 = false ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 PyObject * obj2 = 0 ;
5109 PyObject * obj3 = 0 ;
5110 PyObject * obj4 = 0 ;
5111 PyObject * obj5 = 0 ;
5112 PyObject * obj6 = 0 ;
5113 PyObject * obj7 = 0 ;
5114 PyObject * obj8 = 0 ;
5115 char *kwnames[] = {
5116 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5117 };
5118
5119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5120 {
5121 arg1 = wxString_in_helper(obj0);
5122 if (arg1 == NULL) SWIG_fail;
5123 temp1 = true;
5124 }
5125 {
5126 arg2 = wxString_in_helper(obj1);
5127 if (arg2 == NULL) SWIG_fail;
5128 temp2 = true;
5129 }
5130 {
5131 arg3 = PyList_Size(obj2);
5132 arg4 = wxString_LIST_helper(obj2);
5133 if (arg4 == NULL) SWIG_fail;
5134 }
5135 if (obj3) {
5136 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5137 if (SWIG_arg_fail(5)) SWIG_fail;
5138 }
5139 if (obj4) {
5140 {
5141 arg6 = (int)(SWIG_As_int(obj4));
5142 if (SWIG_arg_fail(6)) SWIG_fail;
5143 }
5144 }
5145 if (obj5) {
5146 {
5147 arg7 = (int)(SWIG_As_int(obj5));
5148 if (SWIG_arg_fail(7)) SWIG_fail;
5149 }
5150 }
5151 if (obj6) {
5152 {
5153 arg8 = (bool)(SWIG_As_bool(obj6));
5154 if (SWIG_arg_fail(8)) SWIG_fail;
5155 }
5156 }
5157 if (obj7) {
5158 {
5159 arg9 = (int)(SWIG_As_int(obj7));
5160 if (SWIG_arg_fail(9)) SWIG_fail;
5161 }
5162 }
5163 if (obj8) {
5164 {
5165 arg10 = (int)(SWIG_As_int(obj8));
5166 if (SWIG_arg_fail(10)) SWIG_fail;
5167 }
5168 }
5169 {
5170 if (!wxPyCheckForApp()) SWIG_fail;
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5173
5174 wxPyEndAllowThreads(__tstate);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 {
5178 #if wxUSE_UNICODE
5179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5180 #else
5181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5182 #endif
5183 }
5184 {
5185 if (temp1)
5186 delete arg1;
5187 }
5188 {
5189 if (temp2)
5190 delete arg2;
5191 }
5192 {
5193 if (arg4) delete [] arg4;
5194 }
5195 return resultobj;
5196 fail:
5197 {
5198 if (temp1)
5199 delete arg1;
5200 }
5201 {
5202 if (temp2)
5203 delete arg2;
5204 }
5205 {
5206 if (arg4) delete [] arg4;
5207 }
5208 return NULL;
5209 }
5210
5211
5212 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5213 PyObject *resultobj;
5214 wxString *arg1 = 0 ;
5215 wxString *arg2 = 0 ;
5216 int arg3 ;
5217 wxString *arg4 = (wxString *) 0 ;
5218 wxWindow *arg5 = (wxWindow *) NULL ;
5219 int arg6 = (int) -1 ;
5220 int arg7 = (int) -1 ;
5221 bool arg8 = (bool) true ;
5222 int arg9 = (int) 150 ;
5223 int arg10 = (int) 200 ;
5224 int result;
5225 bool temp1 = false ;
5226 bool temp2 = false ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 PyObject * obj2 = 0 ;
5230 PyObject * obj3 = 0 ;
5231 PyObject * obj4 = 0 ;
5232 PyObject * obj5 = 0 ;
5233 PyObject * obj6 = 0 ;
5234 PyObject * obj7 = 0 ;
5235 PyObject * obj8 = 0 ;
5236 char *kwnames[] = {
5237 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5238 };
5239
5240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5241 {
5242 arg1 = wxString_in_helper(obj0);
5243 if (arg1 == NULL) SWIG_fail;
5244 temp1 = true;
5245 }
5246 {
5247 arg2 = wxString_in_helper(obj1);
5248 if (arg2 == NULL) SWIG_fail;
5249 temp2 = true;
5250 }
5251 {
5252 arg3 = PyList_Size(obj2);
5253 arg4 = wxString_LIST_helper(obj2);
5254 if (arg4 == NULL) SWIG_fail;
5255 }
5256 if (obj3) {
5257 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5258 if (SWIG_arg_fail(5)) SWIG_fail;
5259 }
5260 if (obj4) {
5261 {
5262 arg6 = (int)(SWIG_As_int(obj4));
5263 if (SWIG_arg_fail(6)) SWIG_fail;
5264 }
5265 }
5266 if (obj5) {
5267 {
5268 arg7 = (int)(SWIG_As_int(obj5));
5269 if (SWIG_arg_fail(7)) SWIG_fail;
5270 }
5271 }
5272 if (obj6) {
5273 {
5274 arg8 = (bool)(SWIG_As_bool(obj6));
5275 if (SWIG_arg_fail(8)) SWIG_fail;
5276 }
5277 }
5278 if (obj7) {
5279 {
5280 arg9 = (int)(SWIG_As_int(obj7));
5281 if (SWIG_arg_fail(9)) SWIG_fail;
5282 }
5283 }
5284 if (obj8) {
5285 {
5286 arg10 = (int)(SWIG_As_int(obj8));
5287 if (SWIG_arg_fail(10)) SWIG_fail;
5288 }
5289 }
5290 {
5291 if (!wxPyCheckForApp()) SWIG_fail;
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5294
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 {
5299 resultobj = SWIG_From_int((int)(result));
5300 }
5301 {
5302 if (temp1)
5303 delete arg1;
5304 }
5305 {
5306 if (temp2)
5307 delete arg2;
5308 }
5309 {
5310 if (arg4) delete [] arg4;
5311 }
5312 return resultobj;
5313 fail:
5314 {
5315 if (temp1)
5316 delete arg1;
5317 }
5318 {
5319 if (temp2)
5320 delete arg2;
5321 }
5322 {
5323 if (arg4) delete [] arg4;
5324 }
5325 return NULL;
5326 }
5327
5328
5329 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5330 PyObject *resultobj;
5331 wxString *arg1 = 0 ;
5332 wxString const &arg2_defvalue = wxPyEmptyString ;
5333 wxString *arg2 = (wxString *) &arg2_defvalue ;
5334 int arg3 = (int) wxOK|wxCENTRE ;
5335 wxWindow *arg4 = (wxWindow *) NULL ;
5336 int arg5 = (int) -1 ;
5337 int arg6 = (int) -1 ;
5338 int result;
5339 bool temp1 = false ;
5340 bool temp2 = false ;
5341 PyObject * obj0 = 0 ;
5342 PyObject * obj1 = 0 ;
5343 PyObject * obj2 = 0 ;
5344 PyObject * obj3 = 0 ;
5345 PyObject * obj4 = 0 ;
5346 PyObject * obj5 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5352 {
5353 arg1 = wxString_in_helper(obj0);
5354 if (arg1 == NULL) SWIG_fail;
5355 temp1 = true;
5356 }
5357 if (obj1) {
5358 {
5359 arg2 = wxString_in_helper(obj1);
5360 if (arg2 == NULL) SWIG_fail;
5361 temp2 = true;
5362 }
5363 }
5364 if (obj2) {
5365 {
5366 arg3 = (int)(SWIG_As_int(obj2));
5367 if (SWIG_arg_fail(3)) SWIG_fail;
5368 }
5369 }
5370 if (obj3) {
5371 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5372 if (SWIG_arg_fail(4)) SWIG_fail;
5373 }
5374 if (obj4) {
5375 {
5376 arg5 = (int)(SWIG_As_int(obj4));
5377 if (SWIG_arg_fail(5)) SWIG_fail;
5378 }
5379 }
5380 if (obj5) {
5381 {
5382 arg6 = (int)(SWIG_As_int(obj5));
5383 if (SWIG_arg_fail(6)) SWIG_fail;
5384 }
5385 }
5386 {
5387 if (!wxPyCheckForApp()) SWIG_fail;
5388 PyThreadState* __tstate = wxPyBeginAllowThreads();
5389 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5390
5391 wxPyEndAllowThreads(__tstate);
5392 if (PyErr_Occurred()) SWIG_fail;
5393 }
5394 {
5395 resultobj = SWIG_From_int((int)(result));
5396 }
5397 {
5398 if (temp1)
5399 delete arg1;
5400 }
5401 {
5402 if (temp2)
5403 delete arg2;
5404 }
5405 return resultobj;
5406 fail:
5407 {
5408 if (temp1)
5409 delete arg1;
5410 }
5411 {
5412 if (temp2)
5413 delete arg2;
5414 }
5415 return NULL;
5416 }
5417
5418
5419 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5420 PyObject *resultobj;
5421 wxString *arg1 = 0 ;
5422 wxString *arg2 = 0 ;
5423 wxString *arg3 = 0 ;
5424 long arg4 ;
5425 long arg5 = (long) 0 ;
5426 long arg6 = (long) 100 ;
5427 wxWindow *arg7 = (wxWindow *) NULL ;
5428 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5429 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5430 long result;
5431 bool temp1 = false ;
5432 bool temp2 = false ;
5433 bool temp3 = false ;
5434 wxPoint temp8 ;
5435 PyObject * obj0 = 0 ;
5436 PyObject * obj1 = 0 ;
5437 PyObject * obj2 = 0 ;
5438 PyObject * obj3 = 0 ;
5439 PyObject * obj4 = 0 ;
5440 PyObject * obj5 = 0 ;
5441 PyObject * obj6 = 0 ;
5442 PyObject * obj7 = 0 ;
5443 char *kwnames[] = {
5444 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5445 };
5446
5447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5448 {
5449 arg1 = wxString_in_helper(obj0);
5450 if (arg1 == NULL) SWIG_fail;
5451 temp1 = true;
5452 }
5453 {
5454 arg2 = wxString_in_helper(obj1);
5455 if (arg2 == NULL) SWIG_fail;
5456 temp2 = true;
5457 }
5458 {
5459 arg3 = wxString_in_helper(obj2);
5460 if (arg3 == NULL) SWIG_fail;
5461 temp3 = true;
5462 }
5463 {
5464 arg4 = (long)(SWIG_As_long(obj3));
5465 if (SWIG_arg_fail(4)) SWIG_fail;
5466 }
5467 if (obj4) {
5468 {
5469 arg5 = (long)(SWIG_As_long(obj4));
5470 if (SWIG_arg_fail(5)) SWIG_fail;
5471 }
5472 }
5473 if (obj5) {
5474 {
5475 arg6 = (long)(SWIG_As_long(obj5));
5476 if (SWIG_arg_fail(6)) SWIG_fail;
5477 }
5478 }
5479 if (obj6) {
5480 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5481 if (SWIG_arg_fail(7)) SWIG_fail;
5482 }
5483 if (obj7) {
5484 {
5485 arg8 = &temp8;
5486 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5487 }
5488 }
5489 {
5490 if (!wxPyCheckForApp()) SWIG_fail;
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_long((long)(result));
5499 }
5500 {
5501 if (temp1)
5502 delete arg1;
5503 }
5504 {
5505 if (temp2)
5506 delete arg2;
5507 }
5508 {
5509 if (temp3)
5510 delete arg3;
5511 }
5512 return resultobj;
5513 fail:
5514 {
5515 if (temp1)
5516 delete arg1;
5517 }
5518 {
5519 if (temp2)
5520 delete arg2;
5521 }
5522 {
5523 if (temp3)
5524 delete arg3;
5525 }
5526 return NULL;
5527 }
5528
5529
5530 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj;
5532 bool result;
5533 char *kwnames[] = {
5534 NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5538 {
5539 if (!wxPyCheckForApp()) SWIG_fail;
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (bool)wxColourDisplay();
5542
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj;
5557 int result;
5558 char *kwnames[] = {
5559 NULL
5560 };
5561
5562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5563 {
5564 if (!wxPyCheckForApp()) SWIG_fail;
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (int)wxDisplayDepth();
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 resultobj = SWIG_From_int((int)(result));
5573 }
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj;
5582 int result;
5583 char *kwnames[] = {
5584 NULL
5585 };
5586
5587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5588 {
5589 if (!wxPyCheckForApp()) SWIG_fail;
5590 PyThreadState* __tstate = wxPyBeginAllowThreads();
5591 result = (int)wxGetDisplayDepth();
5592
5593 wxPyEndAllowThreads(__tstate);
5594 if (PyErr_Occurred()) SWIG_fail;
5595 }
5596 {
5597 resultobj = SWIG_From_int((int)(result));
5598 }
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
5605 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5606 PyObject *resultobj;
5607 int *arg1 = (int *) 0 ;
5608 int *arg2 = (int *) 0 ;
5609 int temp1 ;
5610 int res1 = 0 ;
5611 int temp2 ;
5612 int res2 = 0 ;
5613 char *kwnames[] = {
5614 NULL
5615 };
5616
5617 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5618 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5620 {
5621 if (!wxPyCheckForApp()) SWIG_fail;
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 wxDisplaySize(arg1,arg2);
5624
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 Py_INCREF(Py_None); resultobj = Py_None;
5629 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5630 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5631 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5632 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj;
5641 wxSize result;
5642 char *kwnames[] = {
5643 NULL
5644 };
5645
5646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5647 {
5648 if (!wxPyCheckForApp()) SWIG_fail;
5649 PyThreadState* __tstate = wxPyBeginAllowThreads();
5650 result = wxGetDisplaySize();
5651
5652 wxPyEndAllowThreads(__tstate);
5653 if (PyErr_Occurred()) SWIG_fail;
5654 }
5655 {
5656 wxSize * resultptr;
5657 resultptr = new wxSize((wxSize &)(result));
5658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5659 }
5660 return resultobj;
5661 fail:
5662 return NULL;
5663 }
5664
5665
5666 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5667 PyObject *resultobj;
5668 int *arg1 = (int *) 0 ;
5669 int *arg2 = (int *) 0 ;
5670 int temp1 ;
5671 int res1 = 0 ;
5672 int temp2 ;
5673 int res2 = 0 ;
5674 char *kwnames[] = {
5675 NULL
5676 };
5677
5678 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5679 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5681 {
5682 if (!wxPyCheckForApp()) SWIG_fail;
5683 PyThreadState* __tstate = wxPyBeginAllowThreads();
5684 wxDisplaySizeMM(arg1,arg2);
5685
5686 wxPyEndAllowThreads(__tstate);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 Py_INCREF(Py_None); resultobj = Py_None;
5690 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5691 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5692 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5693 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj;
5702 wxSize result;
5703 char *kwnames[] = {
5704 NULL
5705 };
5706
5707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5708 {
5709 if (!wxPyCheckForApp()) SWIG_fail;
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = wxGetDisplaySizeMM();
5712
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 {
5717 wxSize * resultptr;
5718 resultptr = new wxSize((wxSize &)(result));
5719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5720 }
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj;
5729 int *arg1 = (int *) 0 ;
5730 int *arg2 = (int *) 0 ;
5731 int *arg3 = (int *) 0 ;
5732 int *arg4 = (int *) 0 ;
5733 int temp1 ;
5734 int res1 = 0 ;
5735 int temp2 ;
5736 int res2 = 0 ;
5737 int temp3 ;
5738 int res3 = 0 ;
5739 int temp4 ;
5740 int res4 = 0 ;
5741 char *kwnames[] = {
5742 NULL
5743 };
5744
5745 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5746 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5747 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5748 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5750 {
5751 if (!wxPyCheckForApp()) SWIG_fail;
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 Py_INCREF(Py_None); resultobj = Py_None;
5759 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5760 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5761 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5762 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5763 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5764 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5765 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5766 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxRect result;
5776 char *kwnames[] = {
5777 NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5781 {
5782 if (!wxPyCheckForApp()) SWIG_fail;
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 result = wxGetClientDisplayRect();
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 wxRect * resultptr;
5791 resultptr = new wxRect((wxRect &)(result));
5792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5793 }
5794 return resultobj;
5795 fail:
5796 return NULL;
5797 }
5798
5799
5800 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5801 PyObject *resultobj;
5802 wxCursor *arg1 = 0 ;
5803 PyObject * obj0 = 0 ;
5804 char *kwnames[] = {
5805 (char *) "cursor", NULL
5806 };
5807
5808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5809 {
5810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5811 if (SWIG_arg_fail(1)) SWIG_fail;
5812 if (arg1 == NULL) {
5813 SWIG_null_ref("wxCursor");
5814 }
5815 if (SWIG_arg_fail(1)) SWIG_fail;
5816 }
5817 {
5818 if (!wxPyCheckForApp()) SWIG_fail;
5819 PyThreadState* __tstate = wxPyBeginAllowThreads();
5820 wxSetCursor(*arg1);
5821
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 Py_INCREF(Py_None); resultobj = Py_None;
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj;
5834 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "cursor", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5841 if (obj0) {
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 }
5845 {
5846 if (!wxPyCheckForApp()) SWIG_fail;
5847 PyThreadState* __tstate = wxPyBeginAllowThreads();
5848 wxBeginBusyCursor(arg1);
5849
5850 wxPyEndAllowThreads(__tstate);
5851 if (PyErr_Occurred()) SWIG_fail;
5852 }
5853 Py_INCREF(Py_None); resultobj = Py_None;
5854 return resultobj;
5855 fail:
5856 return NULL;
5857 }
5858
5859
5860 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj;
5862 wxWindow *result;
5863 char *kwnames[] = {
5864 NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5868 {
5869 if (!wxPyCheckForApp()) SWIG_fail;
5870 PyThreadState* __tstate = wxPyBeginAllowThreads();
5871 result = (wxWindow *)wxGetActiveWindow();
5872
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 {
5877 resultobj = wxPyMake_wxObject(result, 0);
5878 }
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj;
5887 wxPoint *arg1 = 0 ;
5888 wxWindow *result;
5889 wxPoint temp1 ;
5890 PyObject * obj0 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "pt", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5896 {
5897 arg1 = &temp1;
5898 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5899 }
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 {
5909 resultobj = wxPyMake_wxObject(result, 0);
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 wxPoint *arg1 = 0 ;
5920 wxWindow *result;
5921 wxPoint temp1 ;
5922 PyObject * obj0 = 0 ;
5923 char *kwnames[] = {
5924 (char *) "pt", NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5928 {
5929 arg1 = &temp1;
5930 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5931 }
5932 {
5933 if (!wxPyCheckForApp()) SWIG_fail;
5934 PyThreadState* __tstate = wxPyBeginAllowThreads();
5935 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5936
5937 wxPyEndAllowThreads(__tstate);
5938 if (PyErr_Occurred()) SWIG_fail;
5939 }
5940 {
5941 resultobj = wxPyMake_wxObject(result, 0);
5942 }
5943 return resultobj;
5944 fail:
5945 return NULL;
5946 }
5947
5948
5949 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj;
5951 wxWindow *arg1 = (wxWindow *) 0 ;
5952 wxWindow *result;
5953 PyObject * obj0 = 0 ;
5954 char *kwnames[] = {
5955 (char *) "win", NULL
5956 };
5957
5958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5960 if (SWIG_arg_fail(1)) SWIG_fail;
5961 {
5962 if (!wxPyCheckForApp()) SWIG_fail;
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 result = (wxWindow *)wxGetTopLevelParent(arg1);
5965
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 resultobj = wxPyMake_wxObject(result, 0);
5971 }
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj;
5980 wxKeyCode arg1 ;
5981 bool result;
5982 PyObject * obj0 = 0 ;
5983 char *kwnames[] = {
5984 (char *) "key", NULL
5985 };
5986
5987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5988 {
5989 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 }
5992 {
5993 if (!wxPyCheckForApp()) SWIG_fail;
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 char *kwnames[] = {
6012 NULL
6013 };
6014
6015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6016 {
6017 if (!wxPyCheckForApp()) SWIG_fail;
6018 PyThreadState* __tstate = wxPyBeginAllowThreads();
6019 wxWakeUpMainThread();
6020
6021 wxPyEndAllowThreads(__tstate);
6022 if (PyErr_Occurred()) SWIG_fail;
6023 }
6024 Py_INCREF(Py_None); resultobj = Py_None;
6025 return resultobj;
6026 fail:
6027 return NULL;
6028 }
6029
6030
6031 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6032 PyObject *resultobj;
6033 char *kwnames[] = {
6034 NULL
6035 };
6036
6037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6038 {
6039 if (!wxPyCheckForApp()) SWIG_fail;
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 wxMutexGuiEnter();
6042
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 Py_INCREF(Py_None); resultobj = Py_None;
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj;
6055 char *kwnames[] = {
6056 NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6060 {
6061 if (!wxPyCheckForApp()) SWIG_fail;
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 wxMutexGuiLeave();
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 Py_INCREF(Py_None); resultobj = Py_None;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxMutexGuiLocker *result;
6078 char *kwnames[] = {
6079 NULL
6080 };
6081
6082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6083 {
6084 if (!wxPyCheckForApp()) SWIG_fail;
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj;
6100 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6101 PyObject * obj0 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 PyThreadState* __tstate = wxPyBeginAllowThreads();
6111 delete arg1;
6112
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 Py_INCREF(Py_None); resultobj = Py_None;
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6124 PyObject *obj;
6125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6126 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6127 Py_INCREF(obj);
6128 return Py_BuildValue((char *)"");
6129 }
6130 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 bool result;
6133 char *kwnames[] = {
6134 NULL
6135 };
6136
6137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (bool)wxThread_IsMain();
6141
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 {
6146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6147 }
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj;
6156 wxString *arg1 = 0 ;
6157 wxToolTip *result;
6158 bool temp1 = false ;
6159 PyObject * obj0 = 0 ;
6160 char *kwnames[] = {
6161 (char *) "tip", NULL
6162 };
6163
6164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6165 {
6166 arg1 = wxString_in_helper(obj0);
6167 if (arg1 == NULL) SWIG_fail;
6168 temp1 = true;
6169 }
6170 {
6171 if (!wxPyCheckForApp()) SWIG_fail;
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 {
6179 resultobj = wxPyMake_wxObject(result, 1);
6180 }
6181 {
6182 if (temp1)
6183 delete arg1;
6184 }
6185 return resultobj;
6186 fail:
6187 {
6188 if (temp1)
6189 delete arg1;
6190 }
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxToolTip *arg1 = (wxToolTip *) 0 ;
6198 wxString *arg2 = 0 ;
6199 bool temp2 = false ;
6200 PyObject * obj0 = 0 ;
6201 PyObject * obj1 = 0 ;
6202 char *kwnames[] = {
6203 (char *) "self",(char *) "tip", NULL
6204 };
6205
6206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6208 if (SWIG_arg_fail(1)) SWIG_fail;
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 (arg1)->SetTip((wxString const &)*arg2);
6217
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 Py_INCREF(Py_None); resultobj = Py_None;
6222 {
6223 if (temp2)
6224 delete arg2;
6225 }
6226 return resultobj;
6227 fail:
6228 {
6229 if (temp2)
6230 delete arg2;
6231 }
6232 return NULL;
6233 }
6234
6235
6236 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj;
6238 wxToolTip *arg1 = (wxToolTip *) 0 ;
6239 wxString result;
6240 PyObject * obj0 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "self", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 result = (arg1)->GetTip();
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 {
6256 #if wxUSE_UNICODE
6257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6258 #else
6259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6260 #endif
6261 }
6262 return resultobj;
6263 fail:
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxToolTip *arg1 = (wxToolTip *) 0 ;
6271 wxWindow *result;
6272 PyObject * obj0 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (wxWindow *)(arg1)->GetWindow();
6283
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 resultobj = wxPyMake_wxObject(result, 0);
6289 }
6290 return resultobj;
6291 fail:
6292 return NULL;
6293 }
6294
6295
6296 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6297 PyObject *resultobj;
6298 bool arg1 ;
6299 PyObject * obj0 = 0 ;
6300 char *kwnames[] = {
6301 (char *) "flag", NULL
6302 };
6303
6304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6305 {
6306 arg1 = (bool)(SWIG_As_bool(obj0));
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 }
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 wxToolTip::Enable(arg1);
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 Py_INCREF(Py_None); resultobj = Py_None;
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj;
6325 long arg1 ;
6326 PyObject * obj0 = 0 ;
6327 char *kwnames[] = {
6328 (char *) "milliseconds", NULL
6329 };
6330
6331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6332 {
6333 arg1 = (long)(SWIG_As_long(obj0));
6334 if (SWIG_arg_fail(1)) SWIG_fail;
6335 }
6336 {
6337 PyThreadState* __tstate = wxPyBeginAllowThreads();
6338 wxToolTip::SetDelay(arg1);
6339
6340 wxPyEndAllowThreads(__tstate);
6341 if (PyErr_Occurred()) SWIG_fail;
6342 }
6343 Py_INCREF(Py_None); resultobj = Py_None;
6344 return resultobj;
6345 fail:
6346 return NULL;
6347 }
6348
6349
6350 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6351 PyObject *obj;
6352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6353 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6354 Py_INCREF(obj);
6355 return Py_BuildValue((char *)"");
6356 }
6357 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj;
6359 wxWindow *arg1 = (wxWindow *) 0 ;
6360 wxSize *arg2 = 0 ;
6361 wxCaret *result;
6362 wxSize temp2 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "window",(char *) "size", NULL
6367 };
6368
6369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(1)) SWIG_fail;
6372 {
6373 arg2 = &temp2;
6374 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6375 }
6376 {
6377 if (!wxPyCheckForApp()) SWIG_fail;
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxCaret *arg1 = (wxCaret *) 0 ;
6394 PyObject * obj0 = 0 ;
6395 char *kwnames[] = {
6396 (char *) "self", NULL
6397 };
6398
6399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6401 if (SWIG_arg_fail(1)) SWIG_fail;
6402 {
6403 PyThreadState* __tstate = wxPyBeginAllowThreads();
6404 wxCaret_Destroy(arg1);
6405
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 Py_INCREF(Py_None); resultobj = Py_None;
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6417 PyObject *resultobj;
6418 wxCaret *arg1 = (wxCaret *) 0 ;
6419 bool result;
6420 PyObject * obj0 = 0 ;
6421 char *kwnames[] = {
6422 (char *) "self", NULL
6423 };
6424
6425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6427 if (SWIG_arg_fail(1)) SWIG_fail;
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 result = (bool)(arg1)->IsOk();
6431
6432 wxPyEndAllowThreads(__tstate);
6433 if (PyErr_Occurred()) SWIG_fail;
6434 }
6435 {
6436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6437 }
6438 return resultobj;
6439 fail:
6440 return NULL;
6441 }
6442
6443
6444 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6445 PyObject *resultobj;
6446 wxCaret *arg1 = (wxCaret *) 0 ;
6447 bool result;
6448 PyObject * obj0 = 0 ;
6449 char *kwnames[] = {
6450 (char *) "self", NULL
6451 };
6452
6453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6455 if (SWIG_arg_fail(1)) SWIG_fail;
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (bool)(arg1)->IsVisible();
6459
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 {
6464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6465 }
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxCaret *arg1 = (wxCaret *) 0 ;
6475 wxPoint result;
6476 PyObject * obj0 = 0 ;
6477 char *kwnames[] = {
6478 (char *) "self", NULL
6479 };
6480
6481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6483 if (SWIG_arg_fail(1)) SWIG_fail;
6484 {
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (arg1)->GetPosition();
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 {
6492 wxPoint * resultptr;
6493 resultptr = new wxPoint((wxPoint &)(result));
6494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6495 }
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxCaret *arg1 = (wxCaret *) 0 ;
6505 int *arg2 = (int *) 0 ;
6506 int *arg3 = (int *) 0 ;
6507 int temp2 ;
6508 int res2 = 0 ;
6509 int temp3 ;
6510 int res3 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6517 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(1)) SWIG_fail;
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->GetPosition(arg2,arg3);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 Py_INCREF(Py_None); resultobj = Py_None;
6529 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6530 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6531 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6532 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj;
6541 wxCaret *arg1 = (wxCaret *) 0 ;
6542 wxSize result;
6543 PyObject * obj0 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "self", NULL
6546 };
6547
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 {
6552 PyThreadState* __tstate = wxPyBeginAllowThreads();
6553 result = (arg1)->GetSize();
6554
6555 wxPyEndAllowThreads(__tstate);
6556 if (PyErr_Occurred()) SWIG_fail;
6557 }
6558 {
6559 wxSize * resultptr;
6560 resultptr = new wxSize((wxSize &)(result));
6561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6562 }
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxCaret *arg1 = (wxCaret *) 0 ;
6572 int *arg2 = (int *) 0 ;
6573 int *arg3 = (int *) 0 ;
6574 int temp2 ;
6575 int res2 = 0 ;
6576 int temp3 ;
6577 int res3 = 0 ;
6578 PyObject * obj0 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self", NULL
6581 };
6582
6583 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6584 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 (arg1)->GetSize(arg2,arg3);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 Py_INCREF(Py_None); resultobj = Py_None;
6596 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6597 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6598 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6599 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj;
6608 wxCaret *arg1 = (wxCaret *) 0 ;
6609 wxWindow *result;
6610 PyObject * obj0 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (wxWindow *)(arg1)->GetWindow();
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 {
6626 resultobj = wxPyMake_wxObject(result, 0);
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxCaret *arg1 = (wxCaret *) 0 ;
6637 int arg2 ;
6638 int arg3 ;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 PyObject * obj2 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self",(char *) "x",(char *) "y", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 arg2 = (int)(SWIG_As_int(obj1));
6651 if (SWIG_arg_fail(2)) SWIG_fail;
6652 }
6653 {
6654 arg3 = (int)(SWIG_As_int(obj2));
6655 if (SWIG_arg_fail(3)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->Move(arg2,arg3);
6660
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 Py_INCREF(Py_None); resultobj = Py_None;
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6672 PyObject *resultobj;
6673 wxCaret *arg1 = (wxCaret *) 0 ;
6674 wxPoint *arg2 = 0 ;
6675 wxPoint temp2 ;
6676 PyObject * obj0 = 0 ;
6677 PyObject * obj1 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self",(char *) "pt", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 arg2 = &temp2;
6687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->Move((wxPoint const &)*arg2);
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 Py_INCREF(Py_None); resultobj = Py_None;
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6704 PyObject *resultobj;
6705 wxCaret *arg1 = (wxCaret *) 0 ;
6706 int arg2 ;
6707 int arg3 ;
6708 PyObject * obj0 = 0 ;
6709 PyObject * obj1 = 0 ;
6710 PyObject * obj2 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "width",(char *) "height", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 {
6719 arg2 = (int)(SWIG_As_int(obj1));
6720 if (SWIG_arg_fail(2)) SWIG_fail;
6721 }
6722 {
6723 arg3 = (int)(SWIG_As_int(obj2));
6724 if (SWIG_arg_fail(3)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 (arg1)->SetSize(arg2,arg3);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 Py_INCREF(Py_None); resultobj = Py_None;
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxCaret *arg1 = (wxCaret *) 0 ;
6743 wxSize *arg2 = 0 ;
6744 wxSize temp2 ;
6745 PyObject * obj0 = 0 ;
6746 PyObject * obj1 = 0 ;
6747 char *kwnames[] = {
6748 (char *) "self",(char *) "size", NULL
6749 };
6750
6751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6753 if (SWIG_arg_fail(1)) SWIG_fail;
6754 {
6755 arg2 = &temp2;
6756 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6757 }
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 (arg1)->SetSize((wxSize const &)*arg2);
6761
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 Py_INCREF(Py_None); resultobj = Py_None;
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj;
6774 wxCaret *arg1 = (wxCaret *) 0 ;
6775 int arg2 = (int) true ;
6776 PyObject * obj0 = 0 ;
6777 PyObject * obj1 = 0 ;
6778 char *kwnames[] = {
6779 (char *) "self",(char *) "show", NULL
6780 };
6781
6782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6784 if (SWIG_arg_fail(1)) SWIG_fail;
6785 if (obj1) {
6786 {
6787 arg2 = (int)(SWIG_As_int(obj1));
6788 if (SWIG_arg_fail(2)) SWIG_fail;
6789 }
6790 }
6791 {
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 (arg1)->Show(arg2);
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 Py_INCREF(Py_None); resultobj = Py_None;
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj;
6807 wxCaret *arg1 = (wxCaret *) 0 ;
6808 PyObject * obj0 = 0 ;
6809 char *kwnames[] = {
6810 (char *) "self", NULL
6811 };
6812
6813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6815 if (SWIG_arg_fail(1)) SWIG_fail;
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 (arg1)->Hide();
6819
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 Py_INCREF(Py_None); resultobj = Py_None;
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 int result;
6833 char *kwnames[] = {
6834 NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6838 {
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 result = (int)wxCaret::GetBlinkTime();
6841
6842 wxPyEndAllowThreads(__tstate);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 {
6846 resultobj = SWIG_From_int((int)(result));
6847 }
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj;
6856 int arg1 ;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "milliseconds", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6863 {
6864 arg1 = (int)(SWIG_As_int(obj0));
6865 if (SWIG_arg_fail(1)) SWIG_fail;
6866 }
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 wxCaret::SetBlinkTime(arg1);
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 Py_INCREF(Py_None); resultobj = Py_None;
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6882 PyObject *obj;
6883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6884 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6885 Py_INCREF(obj);
6886 return Py_BuildValue((char *)"");
6887 }
6888 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj;
6890 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6891 wxBusyCursor *result;
6892 PyObject * obj0 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "cursor", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6898 if (obj0) {
6899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6900 if (SWIG_arg_fail(1)) SWIG_fail;
6901 }
6902 {
6903 if (!wxPyCheckForApp()) SWIG_fail;
6904 PyThreadState* __tstate = wxPyBeginAllowThreads();
6905 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6920 PyObject * obj0 = 0 ;
6921 char *kwnames[] = {
6922 (char *) "self", NULL
6923 };
6924
6925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6927 if (SWIG_arg_fail(1)) SWIG_fail;
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 delete arg1;
6931
6932 wxPyEndAllowThreads(__tstate);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 Py_INCREF(Py_None); resultobj = Py_None;
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6943 PyObject *obj;
6944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6945 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6946 Py_INCREF(obj);
6947 return Py_BuildValue((char *)"");
6948 }
6949 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj;
6951 wxWindow *arg1 = (wxWindow *) NULL ;
6952 wxWindowDisabler *result;
6953 PyObject * obj0 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "winToSkip", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6959 if (obj0) {
6960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6961 if (SWIG_arg_fail(1)) SWIG_fail;
6962 }
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6967
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj;
6980 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6981 PyObject * obj0 = 0 ;
6982 char *kwnames[] = {
6983 (char *) "self", NULL
6984 };
6985
6986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6988 if (SWIG_arg_fail(1)) SWIG_fail;
6989 {
6990 PyThreadState* __tstate = wxPyBeginAllowThreads();
6991 delete arg1;
6992
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 Py_INCREF(Py_None); resultobj = Py_None;
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7004 PyObject *obj;
7005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7006 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7007 Py_INCREF(obj);
7008 return Py_BuildValue((char *)"");
7009 }
7010 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7011 PyObject *resultobj;
7012 wxString *arg1 = 0 ;
7013 wxBusyInfo *result;
7014 bool temp1 = false ;
7015 PyObject * obj0 = 0 ;
7016 char *kwnames[] = {
7017 (char *) "message", NULL
7018 };
7019
7020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7021 {
7022 arg1 = wxString_in_helper(obj0);
7023 if (arg1 == NULL) SWIG_fail;
7024 temp1 = true;
7025 }
7026 {
7027 if (!wxPyCheckForApp()) SWIG_fail;
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7035 {
7036 if (temp1)
7037 delete arg1;
7038 }
7039 return resultobj;
7040 fail:
7041 {
7042 if (temp1)
7043 delete arg1;
7044 }
7045 return NULL;
7046 }
7047
7048
7049 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7050 PyObject *resultobj;
7051 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7052 PyObject * obj0 = 0 ;
7053 char *kwnames[] = {
7054 (char *) "self", NULL
7055 };
7056
7057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7059 if (SWIG_arg_fail(1)) SWIG_fail;
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 delete arg1;
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 Py_INCREF(Py_None); resultobj = Py_None;
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7075 PyObject *obj;
7076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7077 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7078 Py_INCREF(obj);
7079 return Py_BuildValue((char *)"");
7080 }
7081 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj;
7083 wxStopWatch *result;
7084 char *kwnames[] = {
7085 NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7089 {
7090 PyThreadState* __tstate = wxPyBeginAllowThreads();
7091 result = (wxStopWatch *)new wxStopWatch();
7092
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7104 PyObject *resultobj;
7105 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7106 long arg2 = (long) 0 ;
7107 PyObject * obj0 = 0 ;
7108 PyObject * obj1 = 0 ;
7109 char *kwnames[] = {
7110 (char *) "self",(char *) "t0", NULL
7111 };
7112
7113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7115 if (SWIG_arg_fail(1)) SWIG_fail;
7116 if (obj1) {
7117 {
7118 arg2 = (long)(SWIG_As_long(obj1));
7119 if (SWIG_arg_fail(2)) SWIG_fail;
7120 }
7121 }
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 (arg1)->Start(arg2);
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 Py_INCREF(Py_None); resultobj = Py_None;
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj;
7138 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7139 PyObject * obj0 = 0 ;
7140 char *kwnames[] = {
7141 (char *) "self", NULL
7142 };
7143
7144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 (arg1)->Pause();
7150
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 Py_INCREF(Py_None); resultobj = Py_None;
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj;
7163 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7164 PyObject * obj0 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 PyThreadState* __tstate = wxPyBeginAllowThreads();
7174 (arg1)->Resume();
7175
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 Py_INCREF(Py_None); resultobj = Py_None;
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj;
7188 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7189 long result;
7190 PyObject * obj0 = 0 ;
7191 char *kwnames[] = {
7192 (char *) "self", NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7197 if (SWIG_arg_fail(1)) SWIG_fail;
7198 {
7199 PyThreadState* __tstate = wxPyBeginAllowThreads();
7200 result = (long)((wxStopWatch const *)arg1)->Time();
7201
7202 wxPyEndAllowThreads(__tstate);
7203 if (PyErr_Occurred()) SWIG_fail;
7204 }
7205 {
7206 resultobj = SWIG_From_long((long)(result));
7207 }
7208 return resultobj;
7209 fail:
7210 return NULL;
7211 }
7212
7213
7214 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7215 PyObject *obj;
7216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7217 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7218 Py_INCREF(obj);
7219 return Py_BuildValue((char *)"");
7220 }
7221 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj;
7223 int arg1 = (int) 9 ;
7224 int arg2 = (int) wxID_FILE1 ;
7225 wxFileHistory *result;
7226 PyObject * obj0 = 0 ;
7227 PyObject * obj1 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "maxFiles",(char *) "idBase", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7233 if (obj0) {
7234 {
7235 arg1 = (int)(SWIG_As_int(obj0));
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 }
7238 }
7239 if (obj1) {
7240 {
7241 arg2 = (int)(SWIG_As_int(obj1));
7242 if (SWIG_arg_fail(2)) SWIG_fail;
7243 }
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7262 PyObject * obj0 = 0 ;
7263 char *kwnames[] = {
7264 (char *) "self", NULL
7265 };
7266
7267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7269 if (SWIG_arg_fail(1)) SWIG_fail;
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 delete arg1;
7273
7274 wxPyEndAllowThreads(__tstate);
7275 if (PyErr_Occurred()) SWIG_fail;
7276 }
7277 Py_INCREF(Py_None); resultobj = Py_None;
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7285 PyObject *resultobj;
7286 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7287 wxString *arg2 = 0 ;
7288 bool temp2 = false ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char *kwnames[] = {
7292 (char *) "self",(char *) "file", NULL
7293 };
7294
7295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7297 if (SWIG_arg_fail(1)) SWIG_fail;
7298 {
7299 arg2 = wxString_in_helper(obj1);
7300 if (arg2 == NULL) SWIG_fail;
7301 temp2 = true;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->AddFileToHistory((wxString const &)*arg2);
7306
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 Py_INCREF(Py_None); resultobj = Py_None;
7311 {
7312 if (temp2)
7313 delete arg2;
7314 }
7315 return resultobj;
7316 fail:
7317 {
7318 if (temp2)
7319 delete arg2;
7320 }
7321 return NULL;
7322 }
7323
7324
7325 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj;
7327 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7328 int arg2 ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 char *kwnames[] = {
7332 (char *) "self",(char *) "i", NULL
7333 };
7334
7335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7337 if (SWIG_arg_fail(1)) SWIG_fail;
7338 {
7339 arg2 = (int)(SWIG_As_int(obj1));
7340 if (SWIG_arg_fail(2)) SWIG_fail;
7341 }
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 (arg1)->RemoveFileFromHistory(arg2);
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 Py_INCREF(Py_None); resultobj = Py_None;
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj;
7358 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7359 int result;
7360 PyObject * obj0 = 0 ;
7361 char *kwnames[] = {
7362 (char *) "self", NULL
7363 };
7364
7365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7367 if (SWIG_arg_fail(1)) SWIG_fail;
7368 {
7369 PyThreadState* __tstate = wxPyBeginAllowThreads();
7370 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7371
7372 wxPyEndAllowThreads(__tstate);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 {
7376 resultobj = SWIG_From_int((int)(result));
7377 }
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj;
7386 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7387 wxMenu *arg2 = (wxMenu *) 0 ;
7388 PyObject * obj0 = 0 ;
7389 PyObject * obj1 = 0 ;
7390 char *kwnames[] = {
7391 (char *) "self",(char *) "menu", NULL
7392 };
7393
7394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7396 if (SWIG_arg_fail(1)) SWIG_fail;
7397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(2)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 (arg1)->UseMenu(arg2);
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 Py_INCREF(Py_None); resultobj = Py_None;
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj;
7415 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7416 wxMenu *arg2 = (wxMenu *) 0 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "menu", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(2)) SWIG_fail;
7428 {
7429 PyThreadState* __tstate = wxPyBeginAllowThreads();
7430 (arg1)->RemoveMenu(arg2);
7431
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 Py_INCREF(Py_None); resultobj = Py_None;
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7445 wxConfigBase *arg2 = 0 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self",(char *) "config", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7457 if (SWIG_arg_fail(2)) SWIG_fail;
7458 if (arg2 == NULL) {
7459 SWIG_null_ref("wxConfigBase");
7460 }
7461 if (SWIG_arg_fail(2)) SWIG_fail;
7462 }
7463 {
7464 PyThreadState* __tstate = wxPyBeginAllowThreads();
7465 (arg1)->Load(*arg2);
7466
7467 wxPyEndAllowThreads(__tstate);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 Py_INCREF(Py_None); resultobj = Py_None;
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7480 wxConfigBase *arg2 = 0 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 char *kwnames[] = {
7484 (char *) "self",(char *) "config", NULL
7485 };
7486
7487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(1)) SWIG_fail;
7490 {
7491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7492 if (SWIG_arg_fail(2)) SWIG_fail;
7493 if (arg2 == NULL) {
7494 SWIG_null_ref("wxConfigBase");
7495 }
7496 if (SWIG_arg_fail(2)) SWIG_fail;
7497 }
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 (arg1)->Save(*arg2);
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 Py_INCREF(Py_None); resultobj = Py_None;
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7515 PyObject * obj0 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 (arg1)->AddFilesToMenu();
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 Py_INCREF(Py_None); resultobj = Py_None;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7540 wxMenu *arg2 = (wxMenu *) 0 ;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self",(char *) "menu", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7551 if (SWIG_arg_fail(2)) SWIG_fail;
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 (arg1)->AddFilesToMenu(arg2);
7555
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 Py_INCREF(Py_None); resultobj = Py_None;
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7567 PyObject *resultobj;
7568 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7569 int arg2 ;
7570 wxString result;
7571 PyObject * obj0 = 0 ;
7572 PyObject * obj1 = 0 ;
7573 char *kwnames[] = {
7574 (char *) "self",(char *) "i", NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7579 if (SWIG_arg_fail(1)) SWIG_fail;
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 {
7585 PyThreadState* __tstate = wxPyBeginAllowThreads();
7586 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7587
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 {
7592 #if wxUSE_UNICODE
7593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7594 #else
7595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7596 #endif
7597 }
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7607 int result;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = (int)((wxFileHistory const *)arg1)->GetCount();
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = SWIG_From_int((int)(result));
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7633 PyObject *obj;
7634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7635 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7636 Py_INCREF(obj);
7637 return Py_BuildValue((char *)"");
7638 }
7639 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj;
7641 wxString *arg1 = 0 ;
7642 wxString const &arg2_defvalue = wxPyEmptyString ;
7643 wxString *arg2 = (wxString *) &arg2_defvalue ;
7644 wxSingleInstanceChecker *result;
7645 bool temp1 = false ;
7646 bool temp2 = false ;
7647 PyObject * obj0 = 0 ;
7648 PyObject * obj1 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "name",(char *) "path", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7654 {
7655 arg1 = wxString_in_helper(obj0);
7656 if (arg1 == NULL) SWIG_fail;
7657 temp1 = true;
7658 }
7659 if (obj1) {
7660 {
7661 arg2 = wxString_in_helper(obj1);
7662 if (arg2 == NULL) SWIG_fail;
7663 temp2 = true;
7664 }
7665 }
7666 {
7667 PyThreadState* __tstate = wxPyBeginAllowThreads();
7668 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7669
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7674 {
7675 if (temp1)
7676 delete arg1;
7677 }
7678 {
7679 if (temp2)
7680 delete arg2;
7681 }
7682 return resultobj;
7683 fail:
7684 {
7685 if (temp1)
7686 delete arg1;
7687 }
7688 {
7689 if (temp2)
7690 delete arg2;
7691 }
7692 return NULL;
7693 }
7694
7695
7696 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj;
7698 wxSingleInstanceChecker *result;
7699 char *kwnames[] = {
7700 NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7704 {
7705 PyThreadState* __tstate = wxPyBeginAllowThreads();
7706 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7707
7708 wxPyEndAllowThreads(__tstate);
7709 if (PyErr_Occurred()) SWIG_fail;
7710 }
7711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7721 PyObject * obj0 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "self", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7728 if (SWIG_arg_fail(1)) SWIG_fail;
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 delete arg1;
7732
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 Py_INCREF(Py_None); resultobj = Py_None;
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj;
7745 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7746 wxString *arg2 = 0 ;
7747 wxString const &arg3_defvalue = wxPyEmptyString ;
7748 wxString *arg3 = (wxString *) &arg3_defvalue ;
7749 bool result;
7750 bool temp2 = false ;
7751 bool temp3 = false ;
7752 PyObject * obj0 = 0 ;
7753 PyObject * obj1 = 0 ;
7754 PyObject * obj2 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self",(char *) "name",(char *) "path", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 arg2 = wxString_in_helper(obj1);
7764 if (arg2 == NULL) SWIG_fail;
7765 temp2 = true;
7766 }
7767 if (obj2) {
7768 {
7769 arg3 = wxString_in_helper(obj2);
7770 if (arg3 == NULL) SWIG_fail;
7771 temp3 = true;
7772 }
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 {
7785 if (temp2)
7786 delete arg2;
7787 }
7788 {
7789 if (temp3)
7790 delete arg3;
7791 }
7792 return resultobj;
7793 fail:
7794 {
7795 if (temp2)
7796 delete arg2;
7797 }
7798 {
7799 if (temp3)
7800 delete arg3;
7801 }
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7809 bool result;
7810 PyObject * obj0 = 0 ;
7811 char *kwnames[] = {
7812 (char *) "self", NULL
7813 };
7814
7815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7817 if (SWIG_arg_fail(1)) SWIG_fail;
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7821
7822 wxPyEndAllowThreads(__tstate);
7823 if (PyErr_Occurred()) SWIG_fail;
7824 }
7825 {
7826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7827 }
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7835 PyObject *obj;
7836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7837 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7838 Py_INCREF(obj);
7839 return Py_BuildValue((char *)"");
7840 }
7841 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7842 PyObject *resultobj;
7843 wxWindow *arg1 = (wxWindow *) 0 ;
7844 wxDC *arg2 = 0 ;
7845 bool result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "window",(char *) "dc", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 {
7856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(2)) SWIG_fail;
7858 if (arg2 == NULL) {
7859 SWIG_null_ref("wxDC");
7860 }
7861 if (SWIG_arg_fail(2)) SWIG_fail;
7862 }
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7866
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 {
7871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7872 }
7873 return resultobj;
7874 fail:
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 delete arg1;
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 Py_INCREF(Py_None); resultobj = Py_None;
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj;
7906 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7907 wxString result;
7908 PyObject * obj0 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "self", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7915 if (SWIG_arg_fail(1)) SWIG_fail;
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 result = (arg1)->GetTip();
7919
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 {
7924 #if wxUSE_UNICODE
7925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7926 #else
7927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7928 #endif
7929 }
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7939 size_t result;
7940 PyObject * obj0 = 0 ;
7941 char *kwnames[] = {
7942 (char *) "self", NULL
7943 };
7944
7945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7947 if (SWIG_arg_fail(1)) SWIG_fail;
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (size_t)(arg1)->GetCurrentTip();
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 {
7956 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7957 }
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj;
7966 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7967 wxString *arg2 = 0 ;
7968 wxString result;
7969 bool temp2 = false ;
7970 PyObject * obj0 = 0 ;
7971 PyObject * obj1 = 0 ;
7972 char *kwnames[] = {
7973 (char *) "self",(char *) "tip", NULL
7974 };
7975
7976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7978 if (SWIG_arg_fail(1)) SWIG_fail;
7979 {
7980 arg2 = wxString_in_helper(obj1);
7981 if (arg2 == NULL) SWIG_fail;
7982 temp2 = true;
7983 }
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7987
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 {
7992 #if wxUSE_UNICODE
7993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7994 #else
7995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7996 #endif
7997 }
7998 {
7999 if (temp2)
8000 delete arg2;
8001 }
8002 return resultobj;
8003 fail:
8004 {
8005 if (temp2)
8006 delete arg2;
8007 }
8008 return NULL;
8009 }
8010
8011
8012 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8013 PyObject *obj;
8014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8015 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8016 Py_INCREF(obj);
8017 return Py_BuildValue((char *)"");
8018 }
8019 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 size_t arg1 ;
8022 wxPyTipProvider *result;
8023 PyObject * obj0 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "currentTip", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8029 {
8030 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj;
8049 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8050 PyObject *arg2 = (PyObject *) 0 ;
8051 PyObject *arg3 = (PyObject *) 0 ;
8052 PyObject * obj0 = 0 ;
8053 PyObject * obj1 = 0 ;
8054 PyObject * obj2 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self",(char *) "self",(char *) "_class", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 arg2 = obj1;
8063 arg3 = obj2;
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 (arg1)->_setCallbackInfo(arg2,arg3);
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 Py_INCREF(Py_None); resultobj = Py_None;
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8079 PyObject *obj;
8080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8081 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8082 Py_INCREF(obj);
8083 return Py_BuildValue((char *)"");
8084 }
8085 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj;
8087 wxWindow *arg1 = (wxWindow *) 0 ;
8088 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8089 bool arg3 = (bool) true ;
8090 bool result;
8091 PyObject * obj0 = 0 ;
8092 PyObject * obj1 = 0 ;
8093 PyObject * obj2 = 0 ;
8094 char *kwnames[] = {
8095 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8096 };
8097
8098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8100 if (SWIG_arg_fail(1)) SWIG_fail;
8101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8102 if (SWIG_arg_fail(2)) SWIG_fail;
8103 if (obj2) {
8104 {
8105 arg3 = (bool)(SWIG_As_bool(obj2));
8106 if (SWIG_arg_fail(3)) SWIG_fail;
8107 }
8108 }
8109 {
8110 if (!wxPyCheckForApp()) SWIG_fail;
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 result = (bool)wxShowTip(arg1,arg2,arg3);
8113
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 {
8118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8119 }
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxString *arg1 = 0 ;
8129 size_t arg2 ;
8130 wxTipProvider *result;
8131 bool temp1 = false ;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 char *kwnames[] = {
8135 (char *) "filename",(char *) "currentTip", NULL
8136 };
8137
8138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8139 {
8140 arg1 = wxString_in_helper(obj0);
8141 if (arg1 == NULL) SWIG_fail;
8142 temp1 = true;
8143 }
8144 {
8145 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8146 if (SWIG_arg_fail(2)) SWIG_fail;
8147 }
8148 {
8149 if (!wxPyCheckForApp()) SWIG_fail;
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8157 {
8158 if (temp1)
8159 delete arg1;
8160 }
8161 return resultobj;
8162 fail:
8163 {
8164 if (temp1)
8165 delete arg1;
8166 }
8167 return NULL;
8168 }
8169
8170
8171 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj;
8173 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8174 int arg2 = (int) -1 ;
8175 wxPyTimer *result;
8176 PyObject * obj0 = 0 ;
8177 PyObject * obj1 = 0 ;
8178 char *kwnames[] = {
8179 (char *) "owner",(char *) "id", NULL
8180 };
8181
8182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8183 if (obj0) {
8184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8185 if (SWIG_arg_fail(1)) SWIG_fail;
8186 }
8187 if (obj1) {
8188 {
8189 arg2 = (int)(SWIG_As_int(obj1));
8190 if (SWIG_arg_fail(2)) SWIG_fail;
8191 }
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8211 PyObject * obj0 = 0 ;
8212 char *kwnames[] = {
8213 (char *) "self", NULL
8214 };
8215
8216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 delete arg1;
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 Py_INCREF(Py_None); resultobj = Py_None;
8227 return resultobj;
8228 fail:
8229 return NULL;
8230 }
8231
8232
8233 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8234 PyObject *resultobj;
8235 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8236 PyObject *arg2 = (PyObject *) 0 ;
8237 PyObject *arg3 = (PyObject *) 0 ;
8238 int arg4 = (int) 1 ;
8239 PyObject * obj0 = 0 ;
8240 PyObject * obj1 = 0 ;
8241 PyObject * obj2 = 0 ;
8242 PyObject * obj3 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8249 if (SWIG_arg_fail(1)) SWIG_fail;
8250 arg2 = obj1;
8251 arg3 = obj2;
8252 if (obj3) {
8253 {
8254 arg4 = (int)(SWIG_As_int(obj3));
8255 if (SWIG_arg_fail(4)) SWIG_fail;
8256 }
8257 }
8258 {
8259 PyThreadState* __tstate = wxPyBeginAllowThreads();
8260 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8261
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 Py_INCREF(Py_None); resultobj = Py_None;
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj;
8274 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8275 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8276 int arg3 = (int) -1 ;
8277 PyObject * obj0 = 0 ;
8278 PyObject * obj1 = 0 ;
8279 PyObject * obj2 = 0 ;
8280 char *kwnames[] = {
8281 (char *) "self",(char *) "owner",(char *) "id", NULL
8282 };
8283
8284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8286 if (SWIG_arg_fail(1)) SWIG_fail;
8287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8288 if (SWIG_arg_fail(2)) SWIG_fail;
8289 if (obj2) {
8290 {
8291 arg3 = (int)(SWIG_As_int(obj2));
8292 if (SWIG_arg_fail(3)) SWIG_fail;
8293 }
8294 }
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 (arg1)->SetOwner(arg2,arg3);
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 Py_INCREF(Py_None); resultobj = Py_None;
8303 return resultobj;
8304 fail:
8305 return NULL;
8306 }
8307
8308
8309 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8310 PyObject *resultobj;
8311 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8312 wxEvtHandler *result;
8313 PyObject * obj0 = 0 ;
8314 char *kwnames[] = {
8315 (char *) "self", NULL
8316 };
8317
8318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8320 if (SWIG_arg_fail(1)) SWIG_fail;
8321 {
8322 PyThreadState* __tstate = wxPyBeginAllowThreads();
8323 result = (wxEvtHandler *)(arg1)->GetOwner();
8324
8325 wxPyEndAllowThreads(__tstate);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 {
8329 resultobj = wxPyMake_wxObject(result, 0);
8330 }
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj;
8339 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8340 int arg2 = (int) -1 ;
8341 bool arg3 = (bool) false ;
8342 bool result;
8343 PyObject * obj0 = 0 ;
8344 PyObject * obj1 = 0 ;
8345 PyObject * obj2 = 0 ;
8346 char *kwnames[] = {
8347 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8348 };
8349
8350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8352 if (SWIG_arg_fail(1)) SWIG_fail;
8353 if (obj1) {
8354 {
8355 arg2 = (int)(SWIG_As_int(obj1));
8356 if (SWIG_arg_fail(2)) SWIG_fail;
8357 }
8358 }
8359 if (obj2) {
8360 {
8361 arg3 = (bool)(SWIG_As_bool(obj2));
8362 if (SWIG_arg_fail(3)) SWIG_fail;
8363 }
8364 }
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (bool)(arg1)->Start(arg2,arg3);
8368
8369 wxPyEndAllowThreads(__tstate);
8370 if (PyErr_Occurred()) SWIG_fail;
8371 }
8372 {
8373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8374 }
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8384 PyObject * obj0 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 PyThreadState* __tstate = wxPyBeginAllowThreads();
8394 (arg1)->Stop();
8395
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 Py_INCREF(Py_None); resultobj = Py_None;
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8407 PyObject *resultobj;
8408 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8409 bool result;
8410 PyObject * obj0 = 0 ;
8411 char *kwnames[] = {
8412 (char *) "self", NULL
8413 };
8414
8415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8417 if (SWIG_arg_fail(1)) SWIG_fail;
8418 {
8419 PyThreadState* __tstate = wxPyBeginAllowThreads();
8420 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8421
8422 wxPyEndAllowThreads(__tstate);
8423 if (PyErr_Occurred()) SWIG_fail;
8424 }
8425 {
8426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8427 }
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj;
8436 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8437 int result;
8438 PyObject * obj0 = 0 ;
8439 char *kwnames[] = {
8440 (char *) "self", NULL
8441 };
8442
8443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8445 if (SWIG_arg_fail(1)) SWIG_fail;
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8449
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 {
8454 resultobj = SWIG_From_int((int)(result));
8455 }
8456 return resultobj;
8457 fail:
8458 return NULL;
8459 }
8460
8461
8462 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8463 PyObject *resultobj;
8464 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8465 bool result;
8466 PyObject * obj0 = 0 ;
8467 char *kwnames[] = {
8468 (char *) "self", NULL
8469 };
8470
8471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8473 if (SWIG_arg_fail(1)) SWIG_fail;
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 {
8482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8493 int result;
8494 PyObject * obj0 = 0 ;
8495 char *kwnames[] = {
8496 (char *) "self", NULL
8497 };
8498
8499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8501 if (SWIG_arg_fail(1)) SWIG_fail;
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (int)((wxPyTimer const *)arg1)->GetId();
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 resultobj = SWIG_From_int((int)(result));
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8519 PyObject *obj;
8520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8521 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8522 Py_INCREF(obj);
8523 return Py_BuildValue((char *)"");
8524 }
8525 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8526 PyObject *resultobj;
8527 int arg1 = (int) 0 ;
8528 int arg2 = (int) 0 ;
8529 wxTimerEvent *result;
8530 PyObject * obj0 = 0 ;
8531 PyObject * obj1 = 0 ;
8532 char *kwnames[] = {
8533 (char *) "timerid",(char *) "interval", NULL
8534 };
8535
8536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8537 if (obj0) {
8538 {
8539 arg1 = (int)(SWIG_As_int(obj0));
8540 if (SWIG_arg_fail(1)) SWIG_fail;
8541 }
8542 }
8543 if (obj1) {
8544 {
8545 arg2 = (int)(SWIG_As_int(obj1));
8546 if (SWIG_arg_fail(2)) SWIG_fail;
8547 }
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8557 return resultobj;
8558 fail:
8559 return NULL;
8560 }
8561
8562
8563 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj;
8565 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8566 int result;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "self", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 resultobj = SWIG_From_int((int)(result));
8584 }
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8592 PyObject *obj;
8593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8594 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8595 Py_INCREF(obj);
8596 return Py_BuildValue((char *)"");
8597 }
8598 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8599 PyObject *resultobj;
8600 wxTimer *arg1 = 0 ;
8601 wxTimerRunner *result;
8602 PyObject * obj0 = 0 ;
8603
8604 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8605 {
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 if (arg1 == NULL) {
8609 SWIG_null_ref("wxTimer");
8610 }
8611 if (SWIG_arg_fail(1)) SWIG_fail;
8612 }
8613 {
8614 if (!wxPyCheckForApp()) SWIG_fail;
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8617
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8629 PyObject *resultobj;
8630 wxTimer *arg1 = 0 ;
8631 int arg2 ;
8632 bool arg3 = (bool) false ;
8633 wxTimerRunner *result;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 PyObject * obj2 = 0 ;
8637
8638 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8639 {
8640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8641 if (SWIG_arg_fail(1)) SWIG_fail;
8642 if (arg1 == NULL) {
8643 SWIG_null_ref("wxTimer");
8644 }
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 }
8647 {
8648 arg2 = (int)(SWIG_As_int(obj1));
8649 if (SWIG_arg_fail(2)) SWIG_fail;
8650 }
8651 if (obj2) {
8652 {
8653 arg3 = (bool)(SWIG_As_bool(obj2));
8654 if (SWIG_arg_fail(3)) SWIG_fail;
8655 }
8656 }
8657 {
8658 if (!wxPyCheckForApp()) SWIG_fail;
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8673 int argc;
8674 PyObject *argv[4];
8675 int ii;
8676
8677 argc = PyObject_Length(args);
8678 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8679 argv[ii] = PyTuple_GetItem(args,ii);
8680 }
8681 if (argc == 1) {
8682 int _v;
8683 {
8684 void *ptr = 0;
8685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8686 _v = 0;
8687 PyErr_Clear();
8688 } else {
8689 _v = (ptr != 0);
8690 }
8691 }
8692 if (_v) {
8693 return _wrap_new_TimerRunner__SWIG_0(self,args);
8694 }
8695 }
8696 if ((argc >= 2) && (argc <= 3)) {
8697 int _v;
8698 {
8699 void *ptr = 0;
8700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8701 _v = 0;
8702 PyErr_Clear();
8703 } else {
8704 _v = (ptr != 0);
8705 }
8706 }
8707 if (_v) {
8708 _v = SWIG_Check_int(argv[1]);
8709 if (_v) {
8710 if (argc <= 2) {
8711 return _wrap_new_TimerRunner__SWIG_1(self,args);
8712 }
8713 _v = SWIG_Check_bool(argv[2]);
8714 if (_v) {
8715 return _wrap_new_TimerRunner__SWIG_1(self,args);
8716 }
8717 }
8718 }
8719 }
8720
8721 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8722 return NULL;
8723 }
8724
8725
8726 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj;
8728 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8729 PyObject * obj0 = 0 ;
8730 char *kwnames[] = {
8731 (char *) "self", NULL
8732 };
8733
8734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8736 if (SWIG_arg_fail(1)) SWIG_fail;
8737 {
8738 PyThreadState* __tstate = wxPyBeginAllowThreads();
8739 delete arg1;
8740
8741 wxPyEndAllowThreads(__tstate);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 Py_INCREF(Py_None); resultobj = Py_None;
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj;
8753 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8754 int arg2 ;
8755 bool arg3 = (bool) false ;
8756 PyObject * obj0 = 0 ;
8757 PyObject * obj1 = 0 ;
8758 PyObject * obj2 = 0 ;
8759 char *kwnames[] = {
8760 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8761 };
8762
8763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8765 if (SWIG_arg_fail(1)) SWIG_fail;
8766 {
8767 arg2 = (int)(SWIG_As_int(obj1));
8768 if (SWIG_arg_fail(2)) SWIG_fail;
8769 }
8770 if (obj2) {
8771 {
8772 arg3 = (bool)(SWIG_As_bool(obj2));
8773 if (SWIG_arg_fail(3)) SWIG_fail;
8774 }
8775 }
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Start(arg2,arg3);
8779
8780 wxPyEndAllowThreads(__tstate);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 Py_INCREF(Py_None); resultobj = Py_None;
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8791 PyObject *obj;
8792 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8793 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8794 Py_INCREF(obj);
8795 return Py_BuildValue((char *)"");
8796 }
8797 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj;
8799 wxLog *result;
8800 char *kwnames[] = {
8801 NULL
8802 };
8803
8804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8805 {
8806 PyThreadState* __tstate = wxPyBeginAllowThreads();
8807 result = (wxLog *)new wxLog();
8808
8809 wxPyEndAllowThreads(__tstate);
8810 if (PyErr_Occurred()) SWIG_fail;
8811 }
8812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8813 return resultobj;
8814 fail:
8815 return NULL;
8816 }
8817
8818
8819 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8820 PyObject *resultobj;
8821 bool result;
8822 char *kwnames[] = {
8823 NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 result = (bool)wxLog::IsEnabled();
8830
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 {
8835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj;
8845 bool arg1 = (bool) true ;
8846 bool result;
8847 PyObject * obj0 = 0 ;
8848 char *kwnames[] = {
8849 (char *) "doIt", NULL
8850 };
8851
8852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8853 if (obj0) {
8854 {
8855 arg1 = (bool)(SWIG_As_bool(obj0));
8856 if (SWIG_arg_fail(1)) SWIG_fail;
8857 }
8858 }
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 result = (bool)wxLog::EnableLogging(arg1);
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8868 }
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj;
8877 wxLogLevel arg1 ;
8878 wxChar *arg2 = (wxChar *) 0 ;
8879 time_t arg3 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 PyObject * obj2 = 0 ;
8883 char *kwnames[] = {
8884 (char *) "level",(char *) "szString",(char *) "t", NULL
8885 };
8886
8887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8888 {
8889 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 }
8892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8893 if (SWIG_arg_fail(2)) SWIG_fail;
8894 {
8895 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8896 if (SWIG_arg_fail(3)) SWIG_fail;
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8901
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 Py_INCREF(Py_None); resultobj = Py_None;
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 wxLog *arg1 = (wxLog *) 0 ;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 (arg1)->Flush();
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 Py_INCREF(Py_None); resultobj = Py_None;
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8938 PyObject *resultobj;
8939 char *kwnames[] = {
8940 NULL
8941 };
8942
8943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxLog::FlushActive();
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 Py_INCREF(Py_None); resultobj = Py_None;
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxLog *result;
8961 char *kwnames[] = {
8962 NULL
8963 };
8964
8965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (wxLog *)wxLog::GetActiveTarget();
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 wxLog *arg1 = (wxLog *) 0 ;
8983 wxLog *result;
8984 PyObject * obj0 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "pLogger", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8995
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 char *kwnames[] = {
9009 NULL
9010 };
9011
9012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxLog::Suspend();
9016
9017 wxPyEndAllowThreads(__tstate);
9018 if (PyErr_Occurred()) SWIG_fail;
9019 }
9020 Py_INCREF(Py_None); resultobj = Py_None;
9021 return resultobj;
9022 fail:
9023 return NULL;
9024 }
9025
9026
9027 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj;
9029 char *kwnames[] = {
9030 NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 wxLog::Resume();
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 Py_INCREF(Py_None); resultobj = Py_None;
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9049 PyObject *resultobj;
9050 bool arg1 = (bool) true ;
9051 PyObject * obj0 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "bVerbose", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9057 if (obj0) {
9058 {
9059 arg1 = (bool)(SWIG_As_bool(obj0));
9060 if (SWIG_arg_fail(1)) SWIG_fail;
9061 }
9062 }
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 wxLog::SetVerbose(arg1);
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 Py_INCREF(Py_None); resultobj = Py_None;
9071 return resultobj;
9072 fail:
9073 return NULL;
9074 }
9075
9076
9077 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9078 PyObject *resultobj;
9079 wxLogLevel arg1 ;
9080 PyObject * obj0 = 0 ;
9081 char *kwnames[] = {
9082 (char *) "logLevel", NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9086 {
9087 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9088 if (SWIG_arg_fail(1)) SWIG_fail;
9089 }
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 wxLog::SetLogLevel(arg1);
9093
9094 wxPyEndAllowThreads(__tstate);
9095 if (PyErr_Occurred()) SWIG_fail;
9096 }
9097 Py_INCREF(Py_None); resultobj = Py_None;
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9105 PyObject *resultobj;
9106 char *kwnames[] = {
9107 NULL
9108 };
9109
9110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 wxLog::DontCreateOnDemand();
9114
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 Py_INCREF(Py_None); resultobj = Py_None;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 wxTraceMask arg1 ;
9128 PyObject * obj0 = 0 ;
9129 char *kwnames[] = {
9130 (char *) "ulMask", NULL
9131 };
9132
9133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9134 {
9135 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9136 if (SWIG_arg_fail(1)) SWIG_fail;
9137 }
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 wxLog::SetTraceMask(arg1);
9141
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 Py_INCREF(Py_None); resultobj = Py_None;
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxString *arg1 = 0 ;
9155 bool temp1 = false ;
9156 PyObject * obj0 = 0 ;
9157 char *kwnames[] = {
9158 (char *) "str", NULL
9159 };
9160
9161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9162 {
9163 arg1 = wxString_in_helper(obj0);
9164 if (arg1 == NULL) SWIG_fail;
9165 temp1 = true;
9166 }
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 wxLog::AddTraceMask((wxString const &)*arg1);
9170
9171 wxPyEndAllowThreads(__tstate);
9172 if (PyErr_Occurred()) SWIG_fail;
9173 }
9174 Py_INCREF(Py_None); resultobj = Py_None;
9175 {
9176 if (temp1)
9177 delete arg1;
9178 }
9179 return resultobj;
9180 fail:
9181 {
9182 if (temp1)
9183 delete arg1;
9184 }
9185 return NULL;
9186 }
9187
9188
9189 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj;
9191 wxString *arg1 = 0 ;
9192 bool temp1 = false ;
9193 PyObject * obj0 = 0 ;
9194 char *kwnames[] = {
9195 (char *) "str", NULL
9196 };
9197
9198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9199 {
9200 arg1 = wxString_in_helper(obj0);
9201 if (arg1 == NULL) SWIG_fail;
9202 temp1 = true;
9203 }
9204 {
9205 PyThreadState* __tstate = wxPyBeginAllowThreads();
9206 wxLog::RemoveTraceMask((wxString const &)*arg1);
9207
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 Py_INCREF(Py_None); resultobj = Py_None;
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return resultobj;
9217 fail:
9218 {
9219 if (temp1)
9220 delete arg1;
9221 }
9222 return NULL;
9223 }
9224
9225
9226 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj;
9228 char *kwnames[] = {
9229 NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 wxLog::ClearTraceMasks();
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 Py_INCREF(Py_None); resultobj = Py_None;
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj;
9249 wxArrayString *result;
9250 char *kwnames[] = {
9251 NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 {
9258 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9259 result = (wxArrayString *) &_result_ref;
9260 }
9261
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 {
9266 resultobj = wxArrayString2PyList_helper(*result);
9267 }
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxChar *arg1 = (wxChar *) 0 ;
9277 PyObject * obj0 = 0 ;
9278 char *kwnames[] = {
9279 (char *) "ts", NULL
9280 };
9281
9282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9284 if (SWIG_arg_fail(1)) SWIG_fail;
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 wxLog::SetTimestamp((wxChar const *)arg1);
9288
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 Py_INCREF(Py_None); resultobj = Py_None;
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9300 PyObject *resultobj;
9301 bool result;
9302 char *kwnames[] = {
9303 NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (bool)wxLog::GetVerbose();
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9316 }
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj;
9325 wxTraceMask result;
9326 char *kwnames[] = {
9327 NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (wxTraceMask)wxLog::GetTraceMask();
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 {
9339 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9340 }
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxChar *arg1 = (wxChar *) 0 ;
9350 bool result;
9351 PyObject * obj0 = 0 ;
9352 char *kwnames[] = {
9353 (char *) "mask", NULL
9354 };
9355
9356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9358 if (SWIG_arg_fail(1)) SWIG_fail;
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9368 }
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj;
9377 wxLogLevel result;
9378 char *kwnames[] = {
9379 NULL
9380 };
9381
9382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 result = (wxLogLevel)wxLog::GetLogLevel();
9386
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 {
9391 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9392 }
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxChar *result;
9402 char *kwnames[] = {
9403 NULL
9404 };
9405
9406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9407 {
9408 PyThreadState* __tstate = wxPyBeginAllowThreads();
9409 result = (wxChar *)wxLog::GetTimestamp();
9410
9411 wxPyEndAllowThreads(__tstate);
9412 if (PyErr_Occurred()) SWIG_fail;
9413 }
9414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9415 return resultobj;
9416 fail:
9417 return NULL;
9418 }
9419
9420
9421 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9422 PyObject *resultobj;
9423 wxString result;
9424 char *kwnames[] = {
9425 NULL
9426 };
9427
9428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 result = Log_TimeStamp();
9432
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 #if wxUSE_UNICODE
9438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9439 #else
9440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9441 #endif
9442 }
9443 return resultobj;
9444 fail:
9445 return NULL;
9446 }
9447
9448
9449 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9450 PyObject *resultobj;
9451 wxLog *arg1 = (wxLog *) 0 ;
9452 PyObject * obj0 = 0 ;
9453 char *kwnames[] = {
9454 (char *) "self", NULL
9455 };
9456
9457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9459 if (SWIG_arg_fail(1)) SWIG_fail;
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 wxLog_Destroy(arg1);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 Py_INCREF(Py_None); resultobj = Py_None;
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9475 PyObject *obj;
9476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9477 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9478 Py_INCREF(obj);
9479 return Py_BuildValue((char *)"");
9480 }
9481 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxLogStderr *result;
9484 char *kwnames[] = {
9485 NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (wxLogStderr *)new wxLogStderr();
9492
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9504 PyObject *obj;
9505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9506 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9507 Py_INCREF(obj);
9508 return Py_BuildValue((char *)"");
9509 }
9510 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj;
9512 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9513 wxLogTextCtrl *result;
9514 PyObject * obj0 = 0 ;
9515 char *kwnames[] = {
9516 (char *) "pTextCtrl", NULL
9517 };
9518
9519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9521 if (SWIG_arg_fail(1)) SWIG_fail;
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9537 PyObject *obj;
9538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9539 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9540 Py_INCREF(obj);
9541 return Py_BuildValue((char *)"");
9542 }
9543 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxLogGui *result;
9546 char *kwnames[] = {
9547 NULL
9548 };
9549
9550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (wxLogGui *)new wxLogGui();
9554
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9566 PyObject *obj;
9567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9568 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9569 Py_INCREF(obj);
9570 return Py_BuildValue((char *)"");
9571 }
9572 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj;
9574 wxFrame *arg1 = (wxFrame *) 0 ;
9575 wxString *arg2 = 0 ;
9576 bool arg3 = (bool) true ;
9577 bool arg4 = (bool) true ;
9578 wxLogWindow *result;
9579 bool temp2 = false ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 PyObject * obj2 = 0 ;
9583 PyObject * obj3 = 0 ;
9584 char *kwnames[] = {
9585 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9586 };
9587
9588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9590 if (SWIG_arg_fail(1)) SWIG_fail;
9591 {
9592 arg2 = wxString_in_helper(obj1);
9593 if (arg2 == NULL) SWIG_fail;
9594 temp2 = true;
9595 }
9596 if (obj2) {
9597 {
9598 arg3 = (bool)(SWIG_As_bool(obj2));
9599 if (SWIG_arg_fail(3)) SWIG_fail;
9600 }
9601 }
9602 if (obj3) {
9603 {
9604 arg4 = (bool)(SWIG_As_bool(obj3));
9605 if (SWIG_arg_fail(4)) SWIG_fail;
9606 }
9607 }
9608 {
9609 PyThreadState* __tstate = wxPyBeginAllowThreads();
9610 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9611
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9616 {
9617 if (temp2)
9618 delete arg2;
9619 }
9620 return resultobj;
9621 fail:
9622 {
9623 if (temp2)
9624 delete arg2;
9625 }
9626 return NULL;
9627 }
9628
9629
9630 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj;
9632 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9633 bool arg2 = (bool) true ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char *kwnames[] = {
9637 (char *) "self",(char *) "bShow", NULL
9638 };
9639
9640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9642 if (SWIG_arg_fail(1)) SWIG_fail;
9643 if (obj1) {
9644 {
9645 arg2 = (bool)(SWIG_As_bool(obj1));
9646 if (SWIG_arg_fail(2)) SWIG_fail;
9647 }
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 (arg1)->Show(arg2);
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 Py_INCREF(Py_None); resultobj = Py_None;
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9666 wxFrame *result;
9667 PyObject * obj0 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 {
9676 PyThreadState* __tstate = wxPyBeginAllowThreads();
9677 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9678
9679 wxPyEndAllowThreads(__tstate);
9680 if (PyErr_Occurred()) SWIG_fail;
9681 }
9682 {
9683 resultobj = wxPyMake_wxObject(result, 0);
9684 }
9685 return resultobj;
9686 fail:
9687 return NULL;
9688 }
9689
9690
9691 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9692 PyObject *resultobj;
9693 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9694 wxLog *result;
9695 PyObject * obj0 = 0 ;
9696 char *kwnames[] = {
9697 (char *) "self", NULL
9698 };
9699
9700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9702 if (SWIG_arg_fail(1)) SWIG_fail;
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj;
9719 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9720 bool result;
9721 PyObject * obj0 = 0 ;
9722 char *kwnames[] = {
9723 (char *) "self", NULL
9724 };
9725
9726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9728 if (SWIG_arg_fail(1)) SWIG_fail;
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9732
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 {
9737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9738 }
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj;
9747 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9748 bool arg2 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "bDoPass", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 arg2 = (bool)(SWIG_As_bool(obj1));
9760 if (SWIG_arg_fail(2)) SWIG_fail;
9761 }
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 (arg1)->PassMessages(arg2);
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 Py_INCREF(Py_None); resultobj = Py_None;
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9777 PyObject *obj;
9778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9779 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9780 Py_INCREF(obj);
9781 return Py_BuildValue((char *)"");
9782 }
9783 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxLog *arg1 = (wxLog *) 0 ;
9786 wxLogChain *result;
9787 PyObject * obj0 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "logger", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 result = (wxLogChain *)new wxLogChain(arg1);
9798
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9803 return resultobj;
9804 fail:
9805 return NULL;
9806 }
9807
9808
9809 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9810 PyObject *resultobj;
9811 wxLogChain *arg1 = (wxLogChain *) 0 ;
9812 wxLog *arg2 = (wxLog *) 0 ;
9813 PyObject * obj0 = 0 ;
9814 PyObject * obj1 = 0 ;
9815 char *kwnames[] = {
9816 (char *) "self",(char *) "logger", NULL
9817 };
9818
9819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9821 if (SWIG_arg_fail(1)) SWIG_fail;
9822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9823 if (SWIG_arg_fail(2)) SWIG_fail;
9824 {
9825 PyThreadState* __tstate = wxPyBeginAllowThreads();
9826 (arg1)->SetLog(arg2);
9827
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 Py_INCREF(Py_None); resultobj = Py_None;
9832 return resultobj;
9833 fail:
9834 return NULL;
9835 }
9836
9837
9838 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9839 PyObject *resultobj;
9840 wxLogChain *arg1 = (wxLogChain *) 0 ;
9841 bool arg2 ;
9842 PyObject * obj0 = 0 ;
9843 PyObject * obj1 = 0 ;
9844 char *kwnames[] = {
9845 (char *) "self",(char *) "bDoPass", NULL
9846 };
9847
9848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9850 if (SWIG_arg_fail(1)) SWIG_fail;
9851 {
9852 arg2 = (bool)(SWIG_As_bool(obj1));
9853 if (SWIG_arg_fail(2)) SWIG_fail;
9854 }
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 (arg1)->PassMessages(arg2);
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 Py_INCREF(Py_None); resultobj = Py_None;
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxLogChain *arg1 = (wxLogChain *) 0 ;
9872 bool result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (bool)(arg1)->IsPassingMessages();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxLogChain *arg1 = (wxLogChain *) 0 ;
9900 wxLog *result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (wxLog *)(arg1)->GetOldLog();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9924 PyObject *obj;
9925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9926 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9927 Py_INCREF(obj);
9928 return Py_BuildValue((char *)"");
9929 }
9930 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj;
9932 unsigned long result;
9933 char *kwnames[] = {
9934 NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 result = (unsigned long)wxSysErrorCode();
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 {
9946 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9947 }
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj;
9956 unsigned long arg1 = (unsigned long) 0 ;
9957 wxString result;
9958 PyObject * obj0 = 0 ;
9959 char *kwnames[] = {
9960 (char *) "nErrCode", NULL
9961 };
9962
9963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9964 if (obj0) {
9965 {
9966 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 }
9969 }
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = wxSysErrorMsg(arg1);
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 {
9978 #if wxUSE_UNICODE
9979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9980 #else
9981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9982 #endif
9983 }
9984 return resultobj;
9985 fail:
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 wxString *arg1 = 0 ;
9993 bool temp1 = false ;
9994 PyObject * obj0 = 0 ;
9995 char *kwnames[] = {
9996 (char *) "msg", NULL
9997 };
9998
9999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10000 {
10001 arg1 = wxString_in_helper(obj0);
10002 if (arg1 == NULL) SWIG_fail;
10003 temp1 = true;
10004 }
10005 {
10006 PyThreadState* __tstate = wxPyBeginAllowThreads();
10007 wxPyLogFatalError((wxString const &)*arg1);
10008
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 Py_INCREF(Py_None); resultobj = Py_None;
10013 {
10014 if (temp1)
10015 delete arg1;
10016 }
10017 return resultobj;
10018 fail:
10019 {
10020 if (temp1)
10021 delete arg1;
10022 }
10023 return NULL;
10024 }
10025
10026
10027 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj;
10029 wxString *arg1 = 0 ;
10030 bool temp1 = false ;
10031 PyObject * obj0 = 0 ;
10032 char *kwnames[] = {
10033 (char *) "msg", NULL
10034 };
10035
10036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10037 {
10038 arg1 = wxString_in_helper(obj0);
10039 if (arg1 == NULL) SWIG_fail;
10040 temp1 = true;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 wxPyLogError((wxString const &)*arg1);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 {
10051 if (temp1)
10052 delete arg1;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp1)
10058 delete arg1;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj;
10066 wxString *arg1 = 0 ;
10067 bool temp1 = false ;
10068 PyObject * obj0 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "msg", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10074 {
10075 arg1 = wxString_in_helper(obj0);
10076 if (arg1 == NULL) SWIG_fail;
10077 temp1 = true;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 wxPyLogWarning((wxString const &)*arg1);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 Py_INCREF(Py_None); resultobj = Py_None;
10087 {
10088 if (temp1)
10089 delete arg1;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp1)
10095 delete arg1;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj;
10103 wxString *arg1 = 0 ;
10104 bool temp1 = false ;
10105 PyObject * obj0 = 0 ;
10106 char *kwnames[] = {
10107 (char *) "msg", NULL
10108 };
10109
10110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10111 {
10112 arg1 = wxString_in_helper(obj0);
10113 if (arg1 == NULL) SWIG_fail;
10114 temp1 = true;
10115 }
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 wxPyLogMessage((wxString const &)*arg1);
10119
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 Py_INCREF(Py_None); resultobj = Py_None;
10124 {
10125 if (temp1)
10126 delete arg1;
10127 }
10128 return resultobj;
10129 fail:
10130 {
10131 if (temp1)
10132 delete arg1;
10133 }
10134 return NULL;
10135 }
10136
10137
10138 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10139 PyObject *resultobj;
10140 wxString *arg1 = 0 ;
10141 bool temp1 = false ;
10142 PyObject * obj0 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "msg", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10148 {
10149 arg1 = wxString_in_helper(obj0);
10150 if (arg1 == NULL) SWIG_fail;
10151 temp1 = true;
10152 }
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 wxPyLogInfo((wxString const &)*arg1);
10156
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 Py_INCREF(Py_None); resultobj = Py_None;
10161 {
10162 if (temp1)
10163 delete arg1;
10164 }
10165 return resultobj;
10166 fail:
10167 {
10168 if (temp1)
10169 delete arg1;
10170 }
10171 return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj;
10177 wxString *arg1 = 0 ;
10178 bool temp1 = false ;
10179 PyObject * obj0 = 0 ;
10180 char *kwnames[] = {
10181 (char *) "msg", NULL
10182 };
10183
10184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10185 {
10186 arg1 = wxString_in_helper(obj0);
10187 if (arg1 == NULL) SWIG_fail;
10188 temp1 = true;
10189 }
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 wxPyLogDebug((wxString const &)*arg1);
10193
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 Py_INCREF(Py_None); resultobj = Py_None;
10198 {
10199 if (temp1)
10200 delete arg1;
10201 }
10202 return resultobj;
10203 fail:
10204 {
10205 if (temp1)
10206 delete arg1;
10207 }
10208 return NULL;
10209 }
10210
10211
10212 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10213 PyObject *resultobj;
10214 wxString *arg1 = 0 ;
10215 bool temp1 = false ;
10216 PyObject * obj0 = 0 ;
10217 char *kwnames[] = {
10218 (char *) "msg", NULL
10219 };
10220
10221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10222 {
10223 arg1 = wxString_in_helper(obj0);
10224 if (arg1 == NULL) SWIG_fail;
10225 temp1 = true;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 wxPyLogVerbose((wxString const &)*arg1);
10230
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 Py_INCREF(Py_None); resultobj = Py_None;
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return resultobj;
10240 fail:
10241 {
10242 if (temp1)
10243 delete arg1;
10244 }
10245 return NULL;
10246 }
10247
10248
10249 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj;
10251 wxString *arg1 = 0 ;
10252 bool temp1 = false ;
10253 PyObject * obj0 = 0 ;
10254 char *kwnames[] = {
10255 (char *) "msg", NULL
10256 };
10257
10258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10259 {
10260 arg1 = wxString_in_helper(obj0);
10261 if (arg1 == NULL) SWIG_fail;
10262 temp1 = true;
10263 }
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 wxPyLogStatus((wxString const &)*arg1);
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 Py_INCREF(Py_None); resultobj = Py_None;
10272 {
10273 if (temp1)
10274 delete arg1;
10275 }
10276 return resultobj;
10277 fail:
10278 {
10279 if (temp1)
10280 delete arg1;
10281 }
10282 return NULL;
10283 }
10284
10285
10286 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj;
10288 wxFrame *arg1 = (wxFrame *) 0 ;
10289 wxString *arg2 = 0 ;
10290 bool temp2 = false ;
10291 PyObject * obj0 = 0 ;
10292 PyObject * obj1 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "pFrame",(char *) "msg", NULL
10295 };
10296
10297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10299 if (SWIG_arg_fail(1)) SWIG_fail;
10300 {
10301 arg2 = wxString_in_helper(obj1);
10302 if (arg2 == NULL) SWIG_fail;
10303 temp2 = true;
10304 }
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10308
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 Py_INCREF(Py_None); resultobj = Py_None;
10313 {
10314 if (temp2)
10315 delete arg2;
10316 }
10317 return resultobj;
10318 fail:
10319 {
10320 if (temp2)
10321 delete arg2;
10322 }
10323 return NULL;
10324 }
10325
10326
10327 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10328 PyObject *resultobj;
10329 wxString *arg1 = 0 ;
10330 bool temp1 = false ;
10331 PyObject * obj0 = 0 ;
10332 char *kwnames[] = {
10333 (char *) "msg", NULL
10334 };
10335
10336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10337 {
10338 arg1 = wxString_in_helper(obj0);
10339 if (arg1 == NULL) SWIG_fail;
10340 temp1 = true;
10341 }
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 wxPyLogSysError((wxString const &)*arg1);
10345
10346 wxPyEndAllowThreads(__tstate);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 Py_INCREF(Py_None); resultobj = Py_None;
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return resultobj;
10355 fail:
10356 {
10357 if (temp1)
10358 delete arg1;
10359 }
10360 return NULL;
10361 }
10362
10363
10364 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10365 PyObject *resultobj;
10366 unsigned long arg1 ;
10367 wxString *arg2 = 0 ;
10368 bool temp2 = false ;
10369 PyObject * obj0 = 0 ;
10370 PyObject * obj1 = 0 ;
10371 char *kwnames[] = {
10372 (char *) "level",(char *) "msg", NULL
10373 };
10374
10375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10376 {
10377 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10378 if (SWIG_arg_fail(1)) SWIG_fail;
10379 }
10380 {
10381 arg2 = wxString_in_helper(obj1);
10382 if (arg2 == NULL) SWIG_fail;
10383 temp2 = true;
10384 }
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10388
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 Py_INCREF(Py_None); resultobj = Py_None;
10393 {
10394 if (temp2)
10395 delete arg2;
10396 }
10397 return resultobj;
10398 fail:
10399 {
10400 if (temp2)
10401 delete arg2;
10402 }
10403 return NULL;
10404 }
10405
10406
10407 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10408 PyObject *resultobj;
10409 unsigned long arg1 ;
10410 wxString *arg2 = 0 ;
10411 bool temp2 = false ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414
10415 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10416 {
10417 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10418 if (SWIG_arg_fail(1)) SWIG_fail;
10419 }
10420 {
10421 arg2 = wxString_in_helper(obj1);
10422 if (arg2 == NULL) SWIG_fail;
10423 temp2 = true;
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 wxPyLogTrace(arg1,(wxString const &)*arg2);
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 Py_INCREF(Py_None); resultobj = Py_None;
10433 {
10434 if (temp2)
10435 delete arg2;
10436 }
10437 return resultobj;
10438 fail:
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10448 PyObject *resultobj;
10449 wxString *arg1 = 0 ;
10450 wxString *arg2 = 0 ;
10451 bool temp1 = false ;
10452 bool temp2 = false ;
10453 PyObject * obj0 = 0 ;
10454 PyObject * obj1 = 0 ;
10455
10456 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10457 {
10458 arg1 = wxString_in_helper(obj0);
10459 if (arg1 == NULL) SWIG_fail;
10460 temp1 = true;
10461 }
10462 {
10463 arg2 = wxString_in_helper(obj1);
10464 if (arg2 == NULL) SWIG_fail;
10465 temp2 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10470
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 Py_INCREF(Py_None); resultobj = Py_None;
10475 {
10476 if (temp1)
10477 delete arg1;
10478 }
10479 {
10480 if (temp2)
10481 delete arg2;
10482 }
10483 return resultobj;
10484 fail:
10485 {
10486 if (temp1)
10487 delete arg1;
10488 }
10489 {
10490 if (temp2)
10491 delete arg2;
10492 }
10493 return NULL;
10494 }
10495
10496
10497 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10498 int argc;
10499 PyObject *argv[3];
10500 int ii;
10501
10502 argc = PyObject_Length(args);
10503 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10504 argv[ii] = PyTuple_GetItem(args,ii);
10505 }
10506 if (argc == 2) {
10507 int _v;
10508 {
10509 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10510 }
10511 if (_v) {
10512 {
10513 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10514 }
10515 if (_v) {
10516 return _wrap_LogTrace__SWIG_1(self,args);
10517 }
10518 }
10519 }
10520 if (argc == 2) {
10521 int _v;
10522 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10523 if (_v) {
10524 {
10525 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10526 }
10527 if (_v) {
10528 return _wrap_LogTrace__SWIG_0(self,args);
10529 }
10530 }
10531 }
10532
10533 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10534 return NULL;
10535 }
10536
10537
10538 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10539 PyObject *resultobj;
10540 wxString *arg1 = 0 ;
10541 wxString *arg2 = 0 ;
10542 bool temp1 = false ;
10543 bool temp2 = false ;
10544 PyObject * obj0 = 0 ;
10545 PyObject * obj1 = 0 ;
10546 char *kwnames[] = {
10547 (char *) "title",(char *) "text", NULL
10548 };
10549
10550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10551 {
10552 arg1 = wxString_in_helper(obj0);
10553 if (arg1 == NULL) SWIG_fail;
10554 temp1 = true;
10555 }
10556 {
10557 arg2 = wxString_in_helper(obj1);
10558 if (arg2 == NULL) SWIG_fail;
10559 temp2 = true;
10560 }
10561 {
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10564
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 Py_INCREF(Py_None); resultobj = Py_None;
10569 {
10570 if (temp1)
10571 delete arg1;
10572 }
10573 {
10574 if (temp2)
10575 delete arg2;
10576 }
10577 return resultobj;
10578 fail:
10579 {
10580 if (temp1)
10581 delete arg1;
10582 }
10583 {
10584 if (temp2)
10585 delete arg2;
10586 }
10587 return NULL;
10588 }
10589
10590
10591 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj;
10593 wxLogNull *result;
10594 char *kwnames[] = {
10595 NULL
10596 };
10597
10598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (wxLogNull *)new wxLogNull();
10602
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10607 return resultobj;
10608 fail:
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxLogNull *arg1 = (wxLogNull *) 0 ;
10616 PyObject * obj0 = 0 ;
10617 char *kwnames[] = {
10618 (char *) "self", NULL
10619 };
10620
10621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10623 if (SWIG_arg_fail(1)) SWIG_fail;
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 delete arg1;
10627
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 Py_INCREF(Py_None); resultobj = Py_None;
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10639 PyObject *obj;
10640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10641 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10642 Py_INCREF(obj);
10643 return Py_BuildValue((char *)"");
10644 }
10645 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxPyLog *result;
10648 char *kwnames[] = {
10649 NULL
10650 };
10651
10652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10653 {
10654 PyThreadState* __tstate = wxPyBeginAllowThreads();
10655 result = (wxPyLog *)new wxPyLog();
10656
10657 wxPyEndAllowThreads(__tstate);
10658 if (PyErr_Occurred()) SWIG_fail;
10659 }
10660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10661 return resultobj;
10662 fail:
10663 return NULL;
10664 }
10665
10666
10667 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10668 PyObject *resultobj;
10669 wxPyLog *arg1 = (wxPyLog *) 0 ;
10670 PyObject *arg2 = (PyObject *) 0 ;
10671 PyObject *arg3 = (PyObject *) 0 ;
10672 PyObject * obj0 = 0 ;
10673 PyObject * obj1 = 0 ;
10674 PyObject * obj2 = 0 ;
10675 char *kwnames[] = {
10676 (char *) "self",(char *) "self",(char *) "_class", NULL
10677 };
10678
10679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10681 if (SWIG_arg_fail(1)) SWIG_fail;
10682 arg2 = obj1;
10683 arg3 = obj2;
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 (arg1)->_setCallbackInfo(arg2,arg3);
10687
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 Py_INCREF(Py_None); resultobj = Py_None;
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10699 PyObject *obj;
10700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10701 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10702 Py_INCREF(obj);
10703 return Py_BuildValue((char *)"");
10704 }
10705 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj;
10707 int arg1 ;
10708 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10709 int arg3 = (int) wxKILL_NOCHILDREN ;
10710 wxKillError result;
10711 PyObject * obj0 = 0 ;
10712 PyObject * obj1 = 0 ;
10713 PyObject * obj2 = 0 ;
10714 char *kwnames[] = {
10715 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10716 };
10717
10718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10719 {
10720 arg1 = (int)(SWIG_As_int(obj0));
10721 if (SWIG_arg_fail(1)) SWIG_fail;
10722 }
10723 if (obj1) {
10724 {
10725 arg2 = (wxSignal)(SWIG_As_int(obj1));
10726 if (SWIG_arg_fail(2)) SWIG_fail;
10727 }
10728 }
10729 if (obj2) {
10730 {
10731 arg3 = (int)(SWIG_As_int(obj2));
10732 if (SWIG_arg_fail(3)) SWIG_fail;
10733 }
10734 }
10735 {
10736 PyThreadState* __tstate = wxPyBeginAllowThreads();
10737 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10738
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 resultobj = SWIG_From_int((result));
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj;
10751 int arg1 ;
10752 bool result;
10753 PyObject * obj0 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "pid", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10759 {
10760 arg1 = (int)(SWIG_As_int(obj0));
10761 if (SWIG_arg_fail(1)) SWIG_fail;
10762 }
10763 {
10764 PyThreadState* __tstate = wxPyBeginAllowThreads();
10765 result = (bool)wxPyProcess::Exists(arg1);
10766
10767 wxPyEndAllowThreads(__tstate);
10768 if (PyErr_Occurred()) SWIG_fail;
10769 }
10770 {
10771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10772 }
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj;
10781 wxString *arg1 = 0 ;
10782 int arg2 = (int) wxEXEC_ASYNC ;
10783 wxPyProcess *result;
10784 bool temp1 = false ;
10785 PyObject * obj0 = 0 ;
10786 PyObject * obj1 = 0 ;
10787 char *kwnames[] = {
10788 (char *) "cmd",(char *) "flags", NULL
10789 };
10790
10791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10792 {
10793 arg1 = wxString_in_helper(obj0);
10794 if (arg1 == NULL) SWIG_fail;
10795 temp1 = true;
10796 }
10797 if (obj1) {
10798 {
10799 arg2 = (int)(SWIG_As_int(obj1));
10800 if (SWIG_arg_fail(2)) SWIG_fail;
10801 }
10802 }
10803 {
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10806
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10811 {
10812 if (temp1)
10813 delete arg1;
10814 }
10815 return resultobj;
10816 fail:
10817 {
10818 if (temp1)
10819 delete arg1;
10820 }
10821 return NULL;
10822 }
10823
10824
10825 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10826 PyObject *resultobj;
10827 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10828 int arg2 = (int) -1 ;
10829 wxPyProcess *result;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 char *kwnames[] = {
10833 (char *) "parent",(char *) "id", NULL
10834 };
10835
10836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10837 if (obj0) {
10838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10839 if (SWIG_arg_fail(1)) SWIG_fail;
10840 }
10841 if (obj1) {
10842 {
10843 arg2 = (int)(SWIG_As_int(obj1));
10844 if (SWIG_arg_fail(2)) SWIG_fail;
10845 }
10846 }
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10850
10851 wxPyEndAllowThreads(__tstate);
10852 if (PyErr_Occurred()) SWIG_fail;
10853 }
10854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj;
10863 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10864 PyObject *arg2 = (PyObject *) 0 ;
10865 PyObject *arg3 = (PyObject *) 0 ;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 char *kwnames[] = {
10870 (char *) "self",(char *) "self",(char *) "_class", NULL
10871 };
10872
10873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10875 if (SWIG_arg_fail(1)) SWIG_fail;
10876 arg2 = obj1;
10877 arg3 = obj2;
10878 {
10879 PyThreadState* __tstate = wxPyBeginAllowThreads();
10880 (arg1)->_setCallbackInfo(arg2,arg3);
10881
10882 wxPyEndAllowThreads(__tstate);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 Py_INCREF(Py_None); resultobj = Py_None;
10886 return resultobj;
10887 fail:
10888 return NULL;
10889 }
10890
10891
10892 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10893 PyObject *resultobj;
10894 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10895 int arg2 ;
10896 int arg3 ;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 PyObject * obj2 = 0 ;
10900 char *kwnames[] = {
10901 (char *) "self",(char *) "pid",(char *) "status", NULL
10902 };
10903
10904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10906 if (SWIG_arg_fail(1)) SWIG_fail;
10907 {
10908 arg2 = (int)(SWIG_As_int(obj1));
10909 if (SWIG_arg_fail(2)) SWIG_fail;
10910 }
10911 {
10912 arg3 = (int)(SWIG_As_int(obj2));
10913 if (SWIG_arg_fail(3)) SWIG_fail;
10914 }
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 (arg1)->base_OnTerminate(arg2,arg3);
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 Py_INCREF(Py_None); resultobj = Py_None;
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10932 PyObject * obj0 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 (arg1)->Redirect();
10943
10944 wxPyEndAllowThreads(__tstate);
10945 if (PyErr_Occurred()) SWIG_fail;
10946 }
10947 Py_INCREF(Py_None); resultobj = Py_None;
10948 return resultobj;
10949 fail:
10950 return NULL;
10951 }
10952
10953
10954 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj;
10956 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10957 bool result;
10958 PyObject * obj0 = 0 ;
10959 char *kwnames[] = {
10960 (char *) "self", NULL
10961 };
10962
10963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10965 if (SWIG_arg_fail(1)) SWIG_fail;
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 result = (bool)(arg1)->IsRedirected();
10969
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 {
10974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10975 }
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj;
10984 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10985 PyObject * obj0 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 (arg1)->Detach();
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 Py_INCREF(Py_None); resultobj = Py_None;
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11010 wxInputStream *result;
11011 PyObject * obj0 = 0 ;
11012 char *kwnames[] = {
11013 (char *) "self", NULL
11014 };
11015
11016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11018 if (SWIG_arg_fail(1)) SWIG_fail;
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 result = (wxInputStream *)(arg1)->GetInputStream();
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 {
11027 wxPyInputStream * _ptr = NULL;
11028
11029 if (result) {
11030 _ptr = new wxPyInputStream(result);
11031 }
11032 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj;
11042 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11043 wxInputStream *result;
11044 PyObject * obj0 = 0 ;
11045 char *kwnames[] = {
11046 (char *) "self", NULL
11047 };
11048
11049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11051 if (SWIG_arg_fail(1)) SWIG_fail;
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 result = (wxInputStream *)(arg1)->GetErrorStream();
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 {
11060 wxPyInputStream * _ptr = NULL;
11061
11062 if (result) {
11063 _ptr = new wxPyInputStream(result);
11064 }
11065 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj;
11075 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11076 wxOutputStream *result;
11077 PyObject * obj0 = 0 ;
11078 char *kwnames[] = {
11079 (char *) "self", NULL
11080 };
11081
11082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11084 if (SWIG_arg_fail(1)) SWIG_fail;
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (wxOutputStream *)(arg1)->GetOutputStream();
11088
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj;
11101 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11102 PyObject * obj0 = 0 ;
11103 char *kwnames[] = {
11104 (char *) "self", NULL
11105 };
11106
11107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11109 if (SWIG_arg_fail(1)) SWIG_fail;
11110 {
11111 PyThreadState* __tstate = wxPyBeginAllowThreads();
11112 (arg1)->CloseOutput();
11113
11114 wxPyEndAllowThreads(__tstate);
11115 if (PyErr_Occurred()) SWIG_fail;
11116 }
11117 Py_INCREF(Py_None); resultobj = Py_None;
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11125 PyObject *resultobj;
11126 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11127 bool result;
11128 PyObject * obj0 = 0 ;
11129 char *kwnames[] = {
11130 (char *) "self", NULL
11131 };
11132
11133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11135 if (SWIG_arg_fail(1)) SWIG_fail;
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11139
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 {
11144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11145 }
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj;
11154 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11155 bool result;
11156 PyObject * obj0 = 0 ;
11157 char *kwnames[] = {
11158 (char *) "self", NULL
11159 };
11160
11161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11163 if (SWIG_arg_fail(1)) SWIG_fail;
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 {
11172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11173 }
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11183 bool result;
11184 PyObject * obj0 = 0 ;
11185 char *kwnames[] = {
11186 (char *) "self", NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11191 if (SWIG_arg_fail(1)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11201 }
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11209 PyObject *obj;
11210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11211 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11212 Py_INCREF(obj);
11213 return Py_BuildValue((char *)"");
11214 }
11215 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 int arg1 = (int) 0 ;
11218 int arg2 = (int) 0 ;
11219 int arg3 = (int) 0 ;
11220 wxProcessEvent *result;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 char *kwnames[] = {
11225 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11226 };
11227
11228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11229 if (obj0) {
11230 {
11231 arg1 = (int)(SWIG_As_int(obj0));
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 }
11234 }
11235 if (obj1) {
11236 {
11237 arg2 = (int)(SWIG_As_int(obj1));
11238 if (SWIG_arg_fail(2)) SWIG_fail;
11239 }
11240 }
11241 if (obj2) {
11242 {
11243 arg3 = (int)(SWIG_As_int(obj2));
11244 if (SWIG_arg_fail(3)) SWIG_fail;
11245 }
11246 }
11247 {
11248 PyThreadState* __tstate = wxPyBeginAllowThreads();
11249 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11250
11251 wxPyEndAllowThreads(__tstate);
11252 if (PyErr_Occurred()) SWIG_fail;
11253 }
11254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11255 return resultobj;
11256 fail:
11257 return NULL;
11258 }
11259
11260
11261 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11262 PyObject *resultobj;
11263 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11264 int result;
11265 PyObject * obj0 = 0 ;
11266 char *kwnames[] = {
11267 (char *) "self", NULL
11268 };
11269
11270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11272 if (SWIG_arg_fail(1)) SWIG_fail;
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (int)(arg1)->GetPid();
11276
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 {
11281 resultobj = SWIG_From_int((int)(result));
11282 }
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj;
11291 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11292 int result;
11293 PyObject * obj0 = 0 ;
11294 char *kwnames[] = {
11295 (char *) "self", NULL
11296 };
11297
11298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11300 if (SWIG_arg_fail(1)) SWIG_fail;
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (int)(arg1)->GetExitCode();
11304
11305 wxPyEndAllowThreads(__tstate);
11306 if (PyErr_Occurred()) SWIG_fail;
11307 }
11308 {
11309 resultobj = SWIG_From_int((int)(result));
11310 }
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj;
11319 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11320 int arg2 ;
11321 PyObject * obj0 = 0 ;
11322 PyObject * obj1 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "self",(char *) "m_pid", NULL
11325 };
11326
11327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11329 if (SWIG_arg_fail(1)) SWIG_fail;
11330 {
11331 arg2 = (int)(SWIG_As_int(obj1));
11332 if (SWIG_arg_fail(2)) SWIG_fail;
11333 }
11334 if (arg1) (arg1)->m_pid = arg2;
11335
11336 Py_INCREF(Py_None); resultobj = Py_None;
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj;
11345 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11346 int result;
11347 PyObject * obj0 = 0 ;
11348 char *kwnames[] = {
11349 (char *) "self", NULL
11350 };
11351
11352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11354 if (SWIG_arg_fail(1)) SWIG_fail;
11355 result = (int) ((arg1)->m_pid);
11356
11357 {
11358 resultobj = SWIG_From_int((int)(result));
11359 }
11360 return resultobj;
11361 fail:
11362 return NULL;
11363 }
11364
11365
11366 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj;
11368 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11369 int arg2 ;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self",(char *) "m_exitcode", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 arg2 = (int)(SWIG_As_int(obj1));
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 if (arg1) (arg1)->m_exitcode = arg2;
11384
11385 Py_INCREF(Py_None); resultobj = Py_None;
11386 return resultobj;
11387 fail:
11388 return NULL;
11389 }
11390
11391
11392 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11393 PyObject *resultobj;
11394 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11395 int result;
11396 PyObject * obj0 = 0 ;
11397 char *kwnames[] = {
11398 (char *) "self", NULL
11399 };
11400
11401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11403 if (SWIG_arg_fail(1)) SWIG_fail;
11404 result = (int) ((arg1)->m_exitcode);
11405
11406 {
11407 resultobj = SWIG_From_int((int)(result));
11408 }
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11416 PyObject *obj;
11417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11418 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11419 Py_INCREF(obj);
11420 return Py_BuildValue((char *)"");
11421 }
11422 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11423 PyObject *resultobj;
11424 wxString *arg1 = 0 ;
11425 int arg2 = (int) wxEXEC_ASYNC ;
11426 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11427 long result;
11428 bool temp1 = false ;
11429 PyObject * obj0 = 0 ;
11430 PyObject * obj1 = 0 ;
11431 PyObject * obj2 = 0 ;
11432 char *kwnames[] = {
11433 (char *) "command",(char *) "flags",(char *) "process", NULL
11434 };
11435
11436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11437 {
11438 arg1 = wxString_in_helper(obj0);
11439 if (arg1 == NULL) SWIG_fail;
11440 temp1 = true;
11441 }
11442 if (obj1) {
11443 {
11444 arg2 = (int)(SWIG_As_int(obj1));
11445 if (SWIG_arg_fail(2)) SWIG_fail;
11446 }
11447 }
11448 if (obj2) {
11449 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11450 if (SWIG_arg_fail(3)) SWIG_fail;
11451 }
11452 {
11453 if (!wxPyCheckForApp()) SWIG_fail;
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 {
11461 resultobj = SWIG_From_long((long)(result));
11462 }
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return resultobj;
11468 fail:
11469 {
11470 if (temp1)
11471 delete arg1;
11472 }
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj;
11479 long arg1 ;
11480 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11481 wxKillError *arg3 = (wxKillError *) 0 ;
11482 int arg4 = (int) wxKILL_NOCHILDREN ;
11483 int result;
11484 wxKillError temp3 ;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 PyObject * obj2 = 0 ;
11488 char *kwnames[] = {
11489 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11490 };
11491
11492 {
11493 arg3 = &temp3;
11494 }
11495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11496 {
11497 arg1 = (long)(SWIG_As_long(obj0));
11498 if (SWIG_arg_fail(1)) SWIG_fail;
11499 }
11500 if (obj1) {
11501 {
11502 arg2 = (wxSignal)(SWIG_As_int(obj1));
11503 if (SWIG_arg_fail(2)) SWIG_fail;
11504 }
11505 }
11506 if (obj2) {
11507 {
11508 arg4 = (int)(SWIG_As_int(obj2));
11509 if (SWIG_arg_fail(4)) SWIG_fail;
11510 }
11511 }
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 resultobj = SWIG_From_int((int)(result));
11521 }
11522 {
11523 PyObject* o;
11524 o = PyInt_FromLong((long) (*arg3));
11525 resultobj = t_output_helper(resultobj, o);
11526 }
11527 return resultobj;
11528 fail:
11529 return NULL;
11530 }
11531
11532
11533 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11534 PyObject *resultobj;
11535 int arg1 = (int) wxJOYSTICK1 ;
11536 wxJoystick *result;
11537 PyObject * obj0 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "joystick", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11543 if (obj0) {
11544 {
11545 arg1 = (int)(SWIG_As_int(obj0));
11546 if (SWIG_arg_fail(1)) SWIG_fail;
11547 }
11548 }
11549 {
11550 if (!wxPyCheckForApp()) SWIG_fail;
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxJoystick *)new wxJoystick(arg1);
11553
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 wxJoystick *arg1 = (wxJoystick *) 0 ;
11567 PyObject * obj0 = 0 ;
11568 char *kwnames[] = {
11569 (char *) "self", NULL
11570 };
11571
11572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11574 if (SWIG_arg_fail(1)) SWIG_fail;
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 delete arg1;
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 Py_INCREF(Py_None); resultobj = Py_None;
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj;
11591 wxJoystick *arg1 = (wxJoystick *) 0 ;
11592 wxPoint result;
11593 PyObject * obj0 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self", NULL
11596 };
11597
11598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11600 if (SWIG_arg_fail(1)) SWIG_fail;
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = (arg1)->GetPosition();
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 wxPoint * resultptr;
11610 resultptr = new wxPoint((wxPoint &)(result));
11611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11612 }
11613 return resultobj;
11614 fail:
11615 return NULL;
11616 }
11617
11618
11619 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11620 PyObject *resultobj;
11621 wxJoystick *arg1 = (wxJoystick *) 0 ;
11622 int result;
11623 PyObject * obj0 = 0 ;
11624 char *kwnames[] = {
11625 (char *) "self", NULL
11626 };
11627
11628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11630 if (SWIG_arg_fail(1)) SWIG_fail;
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (int)(arg1)->GetZPosition();
11634
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 {
11639 resultobj = SWIG_From_int((int)(result));
11640 }
11641 return resultobj;
11642 fail:
11643 return NULL;
11644 }
11645
11646
11647 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11648 PyObject *resultobj;
11649 wxJoystick *arg1 = (wxJoystick *) 0 ;
11650 int result;
11651 PyObject * obj0 = 0 ;
11652 char *kwnames[] = {
11653 (char *) "self", NULL
11654 };
11655
11656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11658 if (SWIG_arg_fail(1)) SWIG_fail;
11659 {
11660 PyThreadState* __tstate = wxPyBeginAllowThreads();
11661 result = (int)(arg1)->GetButtonState();
11662
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 resultobj = SWIG_From_int((int)(result));
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11676 PyObject *resultobj;
11677 wxJoystick *arg1 = (wxJoystick *) 0 ;
11678 int result;
11679 PyObject * obj0 = 0 ;
11680 char *kwnames[] = {
11681 (char *) "self", NULL
11682 };
11683
11684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11686 if (SWIG_arg_fail(1)) SWIG_fail;
11687 {
11688 PyThreadState* __tstate = wxPyBeginAllowThreads();
11689 result = (int)(arg1)->GetPOVPosition();
11690
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 resultobj = SWIG_From_int((int)(result));
11696 }
11697 return resultobj;
11698 fail:
11699 return NULL;
11700 }
11701
11702
11703 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11704 PyObject *resultobj;
11705 wxJoystick *arg1 = (wxJoystick *) 0 ;
11706 int result;
11707 PyObject * obj0 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 PyThreadState* __tstate = wxPyBeginAllowThreads();
11717 result = (int)(arg1)->GetPOVCTSPosition();
11718
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 {
11723 resultobj = SWIG_From_int((int)(result));
11724 }
11725 return resultobj;
11726 fail:
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxJoystick *arg1 = (wxJoystick *) 0 ;
11734 int result;
11735 PyObject * obj0 = 0 ;
11736 char *kwnames[] = {
11737 (char *) "self", NULL
11738 };
11739
11740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11742 if (SWIG_arg_fail(1)) SWIG_fail;
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (int)(arg1)->GetRudderPosition();
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = SWIG_From_int((int)(result));
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj;
11761 wxJoystick *arg1 = (wxJoystick *) 0 ;
11762 int result;
11763 PyObject * obj0 = 0 ;
11764 char *kwnames[] = {
11765 (char *) "self", NULL
11766 };
11767
11768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11770 if (SWIG_arg_fail(1)) SWIG_fail;
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (int)(arg1)->GetUPosition();
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 {
11779 resultobj = SWIG_From_int((int)(result));
11780 }
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxJoystick *arg1 = (wxJoystick *) 0 ;
11790 int result;
11791 PyObject * obj0 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "self", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11798 if (SWIG_arg_fail(1)) SWIG_fail;
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (int)(arg1)->GetVPosition();
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = SWIG_From_int((int)(result));
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj;
11817 wxJoystick *arg1 = (wxJoystick *) 0 ;
11818 int result;
11819 PyObject * obj0 = 0 ;
11820 char *kwnames[] = {
11821 (char *) "self", NULL
11822 };
11823
11824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11826 if (SWIG_arg_fail(1)) SWIG_fail;
11827 {
11828 PyThreadState* __tstate = wxPyBeginAllowThreads();
11829 result = (int)(arg1)->GetMovementThreshold();
11830
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 {
11835 resultobj = SWIG_From_int((int)(result));
11836 }
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11844 PyObject *resultobj;
11845 wxJoystick *arg1 = (wxJoystick *) 0 ;
11846 int arg2 ;
11847 PyObject * obj0 = 0 ;
11848 PyObject * obj1 = 0 ;
11849 char *kwnames[] = {
11850 (char *) "self",(char *) "threshold", NULL
11851 };
11852
11853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11855 if (SWIG_arg_fail(1)) SWIG_fail;
11856 {
11857 arg2 = (int)(SWIG_As_int(obj1));
11858 if (SWIG_arg_fail(2)) SWIG_fail;
11859 }
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 (arg1)->SetMovementThreshold(arg2);
11863
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 Py_INCREF(Py_None); resultobj = Py_None;
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj;
11876 wxJoystick *arg1 = (wxJoystick *) 0 ;
11877 bool result;
11878 PyObject * obj0 = 0 ;
11879 char *kwnames[] = {
11880 (char *) "self", NULL
11881 };
11882
11883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11885 if (SWIG_arg_fail(1)) SWIG_fail;
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 result = (bool)(arg1)->IsOk();
11889
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 {
11894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11895 }
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj;
11904 wxJoystick *arg1 = (wxJoystick *) 0 ;
11905 int result;
11906 PyObject * obj0 = 0 ;
11907 char *kwnames[] = {
11908 (char *) "self", NULL
11909 };
11910
11911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11913 if (SWIG_arg_fail(1)) SWIG_fail;
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (int)(arg1)->GetNumberJoysticks();
11917
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = SWIG_From_int((int)(result));
11923 }
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj;
11932 wxJoystick *arg1 = (wxJoystick *) 0 ;
11933 int result;
11934 PyObject * obj0 = 0 ;
11935 char *kwnames[] = {
11936 (char *) "self", NULL
11937 };
11938
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11941 if (SWIG_arg_fail(1)) SWIG_fail;
11942 {
11943 PyThreadState* __tstate = wxPyBeginAllowThreads();
11944 result = (int)(arg1)->GetManufacturerId();
11945
11946 wxPyEndAllowThreads(__tstate);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 {
11950 resultobj = SWIG_From_int((int)(result));
11951 }
11952 return resultobj;
11953 fail:
11954 return NULL;
11955 }
11956
11957
11958 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11959 PyObject *resultobj;
11960 wxJoystick *arg1 = (wxJoystick *) 0 ;
11961 int result;
11962 PyObject * obj0 = 0 ;
11963 char *kwnames[] = {
11964 (char *) "self", NULL
11965 };
11966
11967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11969 if (SWIG_arg_fail(1)) SWIG_fail;
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 result = (int)(arg1)->GetProductId();
11973
11974 wxPyEndAllowThreads(__tstate);
11975 if (PyErr_Occurred()) SWIG_fail;
11976 }
11977 {
11978 resultobj = SWIG_From_int((int)(result));
11979 }
11980 return resultobj;
11981 fail:
11982 return NULL;
11983 }
11984
11985
11986 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11987 PyObject *resultobj;
11988 wxJoystick *arg1 = (wxJoystick *) 0 ;
11989 wxString result;
11990 PyObject * obj0 = 0 ;
11991 char *kwnames[] = {
11992 (char *) "self", NULL
11993 };
11994
11995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11997 if (SWIG_arg_fail(1)) SWIG_fail;
11998 {
11999 PyThreadState* __tstate = wxPyBeginAllowThreads();
12000 result = (arg1)->GetProductName();
12001
12002 wxPyEndAllowThreads(__tstate);
12003 if (PyErr_Occurred()) SWIG_fail;
12004 }
12005 {
12006 #if wxUSE_UNICODE
12007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12008 #else
12009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12010 #endif
12011 }
12012 return resultobj;
12013 fail:
12014 return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj;
12020 wxJoystick *arg1 = (wxJoystick *) 0 ;
12021 int result;
12022 PyObject * obj0 = 0 ;
12023 char *kwnames[] = {
12024 (char *) "self", NULL
12025 };
12026
12027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12029 if (SWIG_arg_fail(1)) SWIG_fail;
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (int)(arg1)->GetXMin();
12033
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 resultobj = SWIG_From_int((int)(result));
12039 }
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12047 PyObject *resultobj;
12048 wxJoystick *arg1 = (wxJoystick *) 0 ;
12049 int result;
12050 PyObject * obj0 = 0 ;
12051 char *kwnames[] = {
12052 (char *) "self", NULL
12053 };
12054
12055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12057 if (SWIG_arg_fail(1)) SWIG_fail;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (int)(arg1)->GetYMin();
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 {
12066 resultobj = SWIG_From_int((int)(result));
12067 }
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj;
12076 wxJoystick *arg1 = (wxJoystick *) 0 ;
12077 int result;
12078 PyObject * obj0 = 0 ;
12079 char *kwnames[] = {
12080 (char *) "self", NULL
12081 };
12082
12083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12085 if (SWIG_arg_fail(1)) SWIG_fail;
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (int)(arg1)->GetZMin();
12089
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 {
12094 resultobj = SWIG_From_int((int)(result));
12095 }
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj;
12104 wxJoystick *arg1 = (wxJoystick *) 0 ;
12105 int result;
12106 PyObject * obj0 = 0 ;
12107 char *kwnames[] = {
12108 (char *) "self", NULL
12109 };
12110
12111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12113 if (SWIG_arg_fail(1)) SWIG_fail;
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 result = (int)(arg1)->GetXMax();
12117
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 {
12122 resultobj = SWIG_From_int((int)(result));
12123 }
12124 return resultobj;
12125 fail:
12126 return NULL;
12127 }
12128
12129
12130 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12131 PyObject *resultobj;
12132 wxJoystick *arg1 = (wxJoystick *) 0 ;
12133 int result;
12134 PyObject * obj0 = 0 ;
12135 char *kwnames[] = {
12136 (char *) "self", NULL
12137 };
12138
12139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12141 if (SWIG_arg_fail(1)) SWIG_fail;
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (int)(arg1)->GetYMax();
12145
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 {
12150 resultobj = SWIG_From_int((int)(result));
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj;
12160 wxJoystick *arg1 = (wxJoystick *) 0 ;
12161 int result;
12162 PyObject * obj0 = 0 ;
12163 char *kwnames[] = {
12164 (char *) "self", NULL
12165 };
12166
12167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12169 if (SWIG_arg_fail(1)) SWIG_fail;
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (int)(arg1)->GetZMax();
12173
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 {
12178 resultobj = SWIG_From_int((int)(result));
12179 }
12180 return resultobj;
12181 fail:
12182 return NULL;
12183 }
12184
12185
12186 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12187 PyObject *resultobj;
12188 wxJoystick *arg1 = (wxJoystick *) 0 ;
12189 int result;
12190 PyObject * obj0 = 0 ;
12191 char *kwnames[] = {
12192 (char *) "self", NULL
12193 };
12194
12195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12197 if (SWIG_arg_fail(1)) SWIG_fail;
12198 {
12199 PyThreadState* __tstate = wxPyBeginAllowThreads();
12200 result = (int)(arg1)->GetNumberButtons();
12201
12202 wxPyEndAllowThreads(__tstate);
12203 if (PyErr_Occurred()) SWIG_fail;
12204 }
12205 {
12206 resultobj = SWIG_From_int((int)(result));
12207 }
12208 return resultobj;
12209 fail:
12210 return NULL;
12211 }
12212
12213
12214 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12215 PyObject *resultobj;
12216 wxJoystick *arg1 = (wxJoystick *) 0 ;
12217 int result;
12218 PyObject * obj0 = 0 ;
12219 char *kwnames[] = {
12220 (char *) "self", NULL
12221 };
12222
12223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12225 if (SWIG_arg_fail(1)) SWIG_fail;
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (int)(arg1)->GetNumberAxes();
12229
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 {
12234 resultobj = SWIG_From_int((int)(result));
12235 }
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj;
12244 wxJoystick *arg1 = (wxJoystick *) 0 ;
12245 int result;
12246 PyObject * obj0 = 0 ;
12247 char *kwnames[] = {
12248 (char *) "self", NULL
12249 };
12250
12251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12253 if (SWIG_arg_fail(1)) SWIG_fail;
12254 {
12255 PyThreadState* __tstate = wxPyBeginAllowThreads();
12256 result = (int)(arg1)->GetMaxButtons();
12257
12258 wxPyEndAllowThreads(__tstate);
12259 if (PyErr_Occurred()) SWIG_fail;
12260 }
12261 {
12262 resultobj = SWIG_From_int((int)(result));
12263 }
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12271 PyObject *resultobj;
12272 wxJoystick *arg1 = (wxJoystick *) 0 ;
12273 int result;
12274 PyObject * obj0 = 0 ;
12275 char *kwnames[] = {
12276 (char *) "self", NULL
12277 };
12278
12279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12281 if (SWIG_arg_fail(1)) SWIG_fail;
12282 {
12283 PyThreadState* __tstate = wxPyBeginAllowThreads();
12284 result = (int)(arg1)->GetMaxAxes();
12285
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 {
12290 resultobj = SWIG_From_int((int)(result));
12291 }
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12299 PyObject *resultobj;
12300 wxJoystick *arg1 = (wxJoystick *) 0 ;
12301 int result;
12302 PyObject * obj0 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 result = (int)(arg1)->GetPollingMin();
12313
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 {
12318 resultobj = SWIG_From_int((int)(result));
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj;
12328 wxJoystick *arg1 = (wxJoystick *) 0 ;
12329 int result;
12330 PyObject * obj0 = 0 ;
12331 char *kwnames[] = {
12332 (char *) "self", NULL
12333 };
12334
12335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12337 if (SWIG_arg_fail(1)) SWIG_fail;
12338 {
12339 PyThreadState* __tstate = wxPyBeginAllowThreads();
12340 result = (int)(arg1)->GetPollingMax();
12341
12342 wxPyEndAllowThreads(__tstate);
12343 if (PyErr_Occurred()) SWIG_fail;
12344 }
12345 {
12346 resultobj = SWIG_From_int((int)(result));
12347 }
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12355 PyObject *resultobj;
12356 wxJoystick *arg1 = (wxJoystick *) 0 ;
12357 int result;
12358 PyObject * obj0 = 0 ;
12359 char *kwnames[] = {
12360 (char *) "self", NULL
12361 };
12362
12363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12365 if (SWIG_arg_fail(1)) SWIG_fail;
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (int)(arg1)->GetRudderMin();
12369
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 {
12374 resultobj = SWIG_From_int((int)(result));
12375 }
12376 return resultobj;
12377 fail:
12378 return NULL;
12379 }
12380
12381
12382 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12383 PyObject *resultobj;
12384 wxJoystick *arg1 = (wxJoystick *) 0 ;
12385 int result;
12386 PyObject * obj0 = 0 ;
12387 char *kwnames[] = {
12388 (char *) "self", NULL
12389 };
12390
12391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12393 if (SWIG_arg_fail(1)) SWIG_fail;
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (int)(arg1)->GetRudderMax();
12397
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 {
12402 resultobj = SWIG_From_int((int)(result));
12403 }
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12411 PyObject *resultobj;
12412 wxJoystick *arg1 = (wxJoystick *) 0 ;
12413 int result;
12414 PyObject * obj0 = 0 ;
12415 char *kwnames[] = {
12416 (char *) "self", NULL
12417 };
12418
12419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12421 if (SWIG_arg_fail(1)) SWIG_fail;
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 result = (int)(arg1)->GetUMin();
12425
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 {
12430 resultobj = SWIG_From_int((int)(result));
12431 }
12432 return resultobj;
12433 fail:
12434 return NULL;
12435 }
12436
12437
12438 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12439 PyObject *resultobj;
12440 wxJoystick *arg1 = (wxJoystick *) 0 ;
12441 int result;
12442 PyObject * obj0 = 0 ;
12443 char *kwnames[] = {
12444 (char *) "self", NULL
12445 };
12446
12447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12449 if (SWIG_arg_fail(1)) SWIG_fail;
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = (int)(arg1)->GetUMax();
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 resultobj = SWIG_From_int((int)(result));
12459 }
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj;
12468 wxJoystick *arg1 = (wxJoystick *) 0 ;
12469 int result;
12470 PyObject * obj0 = 0 ;
12471 char *kwnames[] = {
12472 (char *) "self", NULL
12473 };
12474
12475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12477 if (SWIG_arg_fail(1)) SWIG_fail;
12478 {
12479 PyThreadState* __tstate = wxPyBeginAllowThreads();
12480 result = (int)(arg1)->GetVMin();
12481
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 {
12486 resultobj = SWIG_From_int((int)(result));
12487 }
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12495 PyObject *resultobj;
12496 wxJoystick *arg1 = (wxJoystick *) 0 ;
12497 int result;
12498 PyObject * obj0 = 0 ;
12499 char *kwnames[] = {
12500 (char *) "self", NULL
12501 };
12502
12503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12505 if (SWIG_arg_fail(1)) SWIG_fail;
12506 {
12507 PyThreadState* __tstate = wxPyBeginAllowThreads();
12508 result = (int)(arg1)->GetVMax();
12509
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 {
12514 resultobj = SWIG_From_int((int)(result));
12515 }
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj;
12524 wxJoystick *arg1 = (wxJoystick *) 0 ;
12525 bool result;
12526 PyObject * obj0 = 0 ;
12527 char *kwnames[] = {
12528 (char *) "self", NULL
12529 };
12530
12531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12533 if (SWIG_arg_fail(1)) SWIG_fail;
12534 {
12535 PyThreadState* __tstate = wxPyBeginAllowThreads();
12536 result = (bool)(arg1)->HasRudder();
12537
12538 wxPyEndAllowThreads(__tstate);
12539 if (PyErr_Occurred()) SWIG_fail;
12540 }
12541 {
12542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12543 }
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12551 PyObject *resultobj;
12552 wxJoystick *arg1 = (wxJoystick *) 0 ;
12553 bool result;
12554 PyObject * obj0 = 0 ;
12555 char *kwnames[] = {
12556 (char *) "self", NULL
12557 };
12558
12559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12561 if (SWIG_arg_fail(1)) SWIG_fail;
12562 {
12563 PyThreadState* __tstate = wxPyBeginAllowThreads();
12564 result = (bool)(arg1)->HasZ();
12565
12566 wxPyEndAllowThreads(__tstate);
12567 if (PyErr_Occurred()) SWIG_fail;
12568 }
12569 {
12570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12571 }
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12579 PyObject *resultobj;
12580 wxJoystick *arg1 = (wxJoystick *) 0 ;
12581 bool result;
12582 PyObject * obj0 = 0 ;
12583 char *kwnames[] = {
12584 (char *) "self", NULL
12585 };
12586
12587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12589 if (SWIG_arg_fail(1)) SWIG_fail;
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 result = (bool)(arg1)->HasU();
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 {
12598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12599 }
12600 return resultobj;
12601 fail:
12602 return NULL;
12603 }
12604
12605
12606 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12607 PyObject *resultobj;
12608 wxJoystick *arg1 = (wxJoystick *) 0 ;
12609 bool result;
12610 PyObject * obj0 = 0 ;
12611 char *kwnames[] = {
12612 (char *) "self", NULL
12613 };
12614
12615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12617 if (SWIG_arg_fail(1)) SWIG_fail;
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (bool)(arg1)->HasV();
12621
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 {
12626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12627 }
12628 return resultobj;
12629 fail:
12630 return NULL;
12631 }
12632
12633
12634 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj;
12636 wxJoystick *arg1 = (wxJoystick *) 0 ;
12637 bool result;
12638 PyObject * obj0 = 0 ;
12639 char *kwnames[] = {
12640 (char *) "self", NULL
12641 };
12642
12643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12645 if (SWIG_arg_fail(1)) SWIG_fail;
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (bool)(arg1)->HasPOV();
12649
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 {
12654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxJoystick *arg1 = (wxJoystick *) 0 ;
12665 bool result;
12666 PyObject * obj0 = 0 ;
12667 char *kwnames[] = {
12668 (char *) "self", NULL
12669 };
12670
12671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12673 if (SWIG_arg_fail(1)) SWIG_fail;
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = (bool)(arg1)->HasPOV4Dir();
12677
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 {
12682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12683 }
12684 return resultobj;
12685 fail:
12686 return NULL;
12687 }
12688
12689
12690 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12691 PyObject *resultobj;
12692 wxJoystick *arg1 = (wxJoystick *) 0 ;
12693 bool result;
12694 PyObject * obj0 = 0 ;
12695 char *kwnames[] = {
12696 (char *) "self", NULL
12697 };
12698
12699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12701 if (SWIG_arg_fail(1)) SWIG_fail;
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 result = (bool)(arg1)->HasPOVCTS();
12705
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 {
12710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12711 }
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12719 PyObject *resultobj;
12720 wxJoystick *arg1 = (wxJoystick *) 0 ;
12721 wxWindow *arg2 = (wxWindow *) 0 ;
12722 int arg3 = (int) 0 ;
12723 bool result;
12724 PyObject * obj0 = 0 ;
12725 PyObject * obj1 = 0 ;
12726 PyObject * obj2 = 0 ;
12727 char *kwnames[] = {
12728 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12729 };
12730
12731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12733 if (SWIG_arg_fail(1)) SWIG_fail;
12734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12735 if (SWIG_arg_fail(2)) SWIG_fail;
12736 if (obj2) {
12737 {
12738 arg3 = (int)(SWIG_As_int(obj2));
12739 if (SWIG_arg_fail(3)) SWIG_fail;
12740 }
12741 }
12742 {
12743 PyThreadState* __tstate = wxPyBeginAllowThreads();
12744 result = (bool)(arg1)->SetCapture(arg2,arg3);
12745
12746 wxPyEndAllowThreads(__tstate);
12747 if (PyErr_Occurred()) SWIG_fail;
12748 }
12749 {
12750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12751 }
12752 return resultobj;
12753 fail:
12754 return NULL;
12755 }
12756
12757
12758 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12759 PyObject *resultobj;
12760 wxJoystick *arg1 = (wxJoystick *) 0 ;
12761 bool result;
12762 PyObject * obj0 = 0 ;
12763 char *kwnames[] = {
12764 (char *) "self", NULL
12765 };
12766
12767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12769 if (SWIG_arg_fail(1)) SWIG_fail;
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 result = (bool)(arg1)->ReleaseCapture();
12773
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 {
12778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12779 }
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12787 PyObject *obj;
12788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12789 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12790 Py_INCREF(obj);
12791 return Py_BuildValue((char *)"");
12792 }
12793 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj;
12795 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12796 int arg2 = (int) 0 ;
12797 int arg3 = (int) wxJOYSTICK1 ;
12798 int arg4 = (int) 0 ;
12799 wxJoystickEvent *result;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 PyObject * obj2 = 0 ;
12803 PyObject * obj3 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12809 if (obj0) {
12810 {
12811 arg1 = (wxEventType)(SWIG_As_int(obj0));
12812 if (SWIG_arg_fail(1)) SWIG_fail;
12813 }
12814 }
12815 if (obj1) {
12816 {
12817 arg2 = (int)(SWIG_As_int(obj1));
12818 if (SWIG_arg_fail(2)) SWIG_fail;
12819 }
12820 }
12821 if (obj2) {
12822 {
12823 arg3 = (int)(SWIG_As_int(obj2));
12824 if (SWIG_arg_fail(3)) SWIG_fail;
12825 }
12826 }
12827 if (obj3) {
12828 {
12829 arg4 = (int)(SWIG_As_int(obj3));
12830 if (SWIG_arg_fail(4)) SWIG_fail;
12831 }
12832 }
12833 {
12834 PyThreadState* __tstate = wxPyBeginAllowThreads();
12835 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12836
12837 wxPyEndAllowThreads(__tstate);
12838 if (PyErr_Occurred()) SWIG_fail;
12839 }
12840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12848 PyObject *resultobj;
12849 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12850 wxPoint result;
12851 PyObject * obj0 = 0 ;
12852 char *kwnames[] = {
12853 (char *) "self", NULL
12854 };
12855
12856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12858 if (SWIG_arg_fail(1)) SWIG_fail;
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12862
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 {
12867 wxPoint * resultptr;
12868 resultptr = new wxPoint((wxPoint &)(result));
12869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12870 }
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj;
12879 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12880 int result;
12881 PyObject * obj0 = 0 ;
12882 char *kwnames[] = {
12883 (char *) "self", NULL
12884 };
12885
12886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12888 if (SWIG_arg_fail(1)) SWIG_fail;
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 {
12897 resultobj = SWIG_From_int((int)(result));
12898 }
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12906 PyObject *resultobj;
12907 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12908 int result;
12909 PyObject * obj0 = 0 ;
12910 char *kwnames[] = {
12911 (char *) "self", NULL
12912 };
12913
12914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12916 if (SWIG_arg_fail(1)) SWIG_fail;
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12920
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 {
12925 resultobj = SWIG_From_int((int)(result));
12926 }
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj;
12935 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12936 int result;
12937 PyObject * obj0 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "self", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12944 if (SWIG_arg_fail(1)) SWIG_fail;
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 {
12953 resultobj = SWIG_From_int((int)(result));
12954 }
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12962 PyObject *resultobj;
12963 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12964 int result;
12965 PyObject * obj0 = 0 ;
12966 char *kwnames[] = {
12967 (char *) "self", NULL
12968 };
12969
12970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12972 if (SWIG_arg_fail(1)) SWIG_fail;
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12976
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 {
12981 resultobj = SWIG_From_int((int)(result));
12982 }
12983 return resultobj;
12984 fail:
12985 return NULL;
12986 }
12987
12988
12989 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12990 PyObject *resultobj;
12991 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12992 int arg2 ;
12993 PyObject * obj0 = 0 ;
12994 PyObject * obj1 = 0 ;
12995 char *kwnames[] = {
12996 (char *) "self",(char *) "stick", NULL
12997 };
12998
12999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13001 if (SWIG_arg_fail(1)) SWIG_fail;
13002 {
13003 arg2 = (int)(SWIG_As_int(obj1));
13004 if (SWIG_arg_fail(2)) SWIG_fail;
13005 }
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 (arg1)->SetJoystick(arg2);
13009
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 Py_INCREF(Py_None); resultobj = Py_None;
13014 return resultobj;
13015 fail:
13016 return NULL;
13017 }
13018
13019
13020 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj;
13022 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13023 int arg2 ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 char *kwnames[] = {
13027 (char *) "self",(char *) "state", NULL
13028 };
13029
13030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13032 if (SWIG_arg_fail(1)) SWIG_fail;
13033 {
13034 arg2 = (int)(SWIG_As_int(obj1));
13035 if (SWIG_arg_fail(2)) SWIG_fail;
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 (arg1)->SetButtonState(arg2);
13040
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 Py_INCREF(Py_None); resultobj = Py_None;
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13054 int arg2 ;
13055 PyObject * obj0 = 0 ;
13056 PyObject * obj1 = 0 ;
13057 char *kwnames[] = {
13058 (char *) "self",(char *) "change", NULL
13059 };
13060
13061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13063 if (SWIG_arg_fail(1)) SWIG_fail;
13064 {
13065 arg2 = (int)(SWIG_As_int(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 {
13069 PyThreadState* __tstate = wxPyBeginAllowThreads();
13070 (arg1)->SetButtonChange(arg2);
13071
13072 wxPyEndAllowThreads(__tstate);
13073 if (PyErr_Occurred()) SWIG_fail;
13074 }
13075 Py_INCREF(Py_None); resultobj = Py_None;
13076 return resultobj;
13077 fail:
13078 return NULL;
13079 }
13080
13081
13082 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj;
13084 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13085 wxPoint *arg2 = 0 ;
13086 wxPoint temp2 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 char *kwnames[] = {
13090 (char *) "self",(char *) "pos", NULL
13091 };
13092
13093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13095 if (SWIG_arg_fail(1)) SWIG_fail;
13096 {
13097 arg2 = &temp2;
13098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13099 }
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 (arg1)->SetPosition((wxPoint const &)*arg2);
13103
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 Py_INCREF(Py_None); resultobj = Py_None;
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj;
13116 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13117 int arg2 ;
13118 PyObject * obj0 = 0 ;
13119 PyObject * obj1 = 0 ;
13120 char *kwnames[] = {
13121 (char *) "self",(char *) "zPos", NULL
13122 };
13123
13124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13126 if (SWIG_arg_fail(1)) SWIG_fail;
13127 {
13128 arg2 = (int)(SWIG_As_int(obj1));
13129 if (SWIG_arg_fail(2)) SWIG_fail;
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 (arg1)->SetZPosition(arg2);
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 Py_INCREF(Py_None); resultobj = Py_None;
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj;
13147 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13148 bool result;
13149 PyObject * obj0 = 0 ;
13150 char *kwnames[] = {
13151 (char *) "self", NULL
13152 };
13153
13154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13156 if (SWIG_arg_fail(1)) SWIG_fail;
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13160
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 {
13165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13166 }
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13176 bool result;
13177 PyObject * obj0 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "self", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13188
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 {
13193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13194 }
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj;
13203 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13204 bool result;
13205 PyObject * obj0 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 {
13221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13222 }
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj;
13231 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13232 int arg2 = (int) wxJOY_BUTTON_ANY ;
13233 bool result;
13234 PyObject * obj0 = 0 ;
13235 PyObject * obj1 = 0 ;
13236 char *kwnames[] = {
13237 (char *) "self",(char *) "but", NULL
13238 };
13239
13240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13242 if (SWIG_arg_fail(1)) SWIG_fail;
13243 if (obj1) {
13244 {
13245 arg2 = (int)(SWIG_As_int(obj1));
13246 if (SWIG_arg_fail(2)) SWIG_fail;
13247 }
13248 }
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13252
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 {
13257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13258 }
13259 return resultobj;
13260 fail:
13261 return NULL;
13262 }
13263
13264
13265 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj;
13267 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13268 int arg2 = (int) wxJOY_BUTTON_ANY ;
13269 bool result;
13270 PyObject * obj0 = 0 ;
13271 PyObject * obj1 = 0 ;
13272 char *kwnames[] = {
13273 (char *) "self",(char *) "but", NULL
13274 };
13275
13276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13278 if (SWIG_arg_fail(1)) SWIG_fail;
13279 if (obj1) {
13280 {
13281 arg2 = (int)(SWIG_As_int(obj1));
13282 if (SWIG_arg_fail(2)) SWIG_fail;
13283 }
13284 }
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13288
13289 wxPyEndAllowThreads(__tstate);
13290 if (PyErr_Occurred()) SWIG_fail;
13291 }
13292 {
13293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13294 }
13295 return resultobj;
13296 fail:
13297 return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj;
13303 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13304 int arg2 = (int) wxJOY_BUTTON_ANY ;
13305 bool result;
13306 PyObject * obj0 = 0 ;
13307 PyObject * obj1 = 0 ;
13308 char *kwnames[] = {
13309 (char *) "self",(char *) "but", NULL
13310 };
13311
13312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13314 if (SWIG_arg_fail(1)) SWIG_fail;
13315 if (obj1) {
13316 {
13317 arg2 = (int)(SWIG_As_int(obj1));
13318 if (SWIG_arg_fail(2)) SWIG_fail;
13319 }
13320 }
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13324
13325 wxPyEndAllowThreads(__tstate);
13326 if (PyErr_Occurred()) SWIG_fail;
13327 }
13328 {
13329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13330 }
13331 return resultobj;
13332 fail:
13333 return NULL;
13334 }
13335
13336
13337 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13338 PyObject *obj;
13339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13340 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13341 Py_INCREF(obj);
13342 return Py_BuildValue((char *)"");
13343 }
13344 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj;
13346 wxString const &arg1_defvalue = wxPyEmptyString ;
13347 wxString *arg1 = (wxString *) &arg1_defvalue ;
13348 wxSound *result;
13349 bool temp1 = false ;
13350 PyObject * obj0 = 0 ;
13351 char *kwnames[] = {
13352 (char *) "fileName", NULL
13353 };
13354
13355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13356 if (obj0) {
13357 {
13358 arg1 = wxString_in_helper(obj0);
13359 if (arg1 == NULL) SWIG_fail;
13360 temp1 = true;
13361 }
13362 }
13363 {
13364 if (!wxPyCheckForApp()) SWIG_fail;
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13367
13368 wxPyEndAllowThreads(__tstate);
13369 if (PyErr_Occurred()) SWIG_fail;
13370 }
13371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13372 {
13373 if (temp1)
13374 delete arg1;
13375 }
13376 return resultobj;
13377 fail:
13378 {
13379 if (temp1)
13380 delete arg1;
13381 }
13382 return NULL;
13383 }
13384
13385
13386 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13387 PyObject *resultobj;
13388 PyObject *arg1 = (PyObject *) 0 ;
13389 wxSound *result;
13390 PyObject * obj0 = 0 ;
13391 char *kwnames[] = {
13392 (char *) "data", NULL
13393 };
13394
13395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13396 arg1 = obj0;
13397 {
13398 if (!wxPyCheckForApp()) SWIG_fail;
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 result = (wxSound *)new_wxSound(arg1);
13401
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj;
13414 wxSound *arg1 = (wxSound *) 0 ;
13415 PyObject * obj0 = 0 ;
13416 char *kwnames[] = {
13417 (char *) "self", NULL
13418 };
13419
13420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13422 if (SWIG_arg_fail(1)) SWIG_fail;
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 delete arg1;
13426
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 Py_INCREF(Py_None); resultobj = Py_None;
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj;
13439 wxSound *arg1 = (wxSound *) 0 ;
13440 wxString *arg2 = 0 ;
13441 bool result;
13442 bool temp2 = false ;
13443 PyObject * obj0 = 0 ;
13444 PyObject * obj1 = 0 ;
13445 char *kwnames[] = {
13446 (char *) "self",(char *) "fileName", NULL
13447 };
13448
13449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13451 if (SWIG_arg_fail(1)) SWIG_fail;
13452 {
13453 arg2 = wxString_in_helper(obj1);
13454 if (arg2 == NULL) SWIG_fail;
13455 temp2 = true;
13456 }
13457 {
13458 PyThreadState* __tstate = wxPyBeginAllowThreads();
13459 result = (bool)(arg1)->Create((wxString const &)*arg2);
13460
13461 wxPyEndAllowThreads(__tstate);
13462 if (PyErr_Occurred()) SWIG_fail;
13463 }
13464 {
13465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13466 }
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp2)
13475 delete arg2;
13476 }
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxSound *arg1 = (wxSound *) 0 ;
13484 PyObject *arg2 = (PyObject *) 0 ;
13485 bool result;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 char *kwnames[] = {
13489 (char *) "self",(char *) "data", NULL
13490 };
13491
13492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13494 if (SWIG_arg_fail(1)) SWIG_fail;
13495 arg2 = obj1;
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = (bool)wxSound_CreateFromData(arg1,arg2);
13499
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 {
13504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13505 }
13506 return resultobj;
13507 fail:
13508 return NULL;
13509 }
13510
13511
13512 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxSound *arg1 = (wxSound *) 0 ;
13515 bool result;
13516 PyObject * obj0 = 0 ;
13517 char *kwnames[] = {
13518 (char *) "self", NULL
13519 };
13520
13521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13523 if (SWIG_arg_fail(1)) SWIG_fail;
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 result = (bool)(arg1)->IsOk();
13527
13528 wxPyEndAllowThreads(__tstate);
13529 if (PyErr_Occurred()) SWIG_fail;
13530 }
13531 {
13532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13533 }
13534 return resultobj;
13535 fail:
13536 return NULL;
13537 }
13538
13539
13540 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13541 PyObject *resultobj;
13542 wxSound *arg1 = (wxSound *) 0 ;
13543 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13544 bool result;
13545 PyObject * obj0 = 0 ;
13546 PyObject * obj1 = 0 ;
13547 char *kwnames[] = {
13548 (char *) "self",(char *) "flags", NULL
13549 };
13550
13551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13553 if (SWIG_arg_fail(1)) SWIG_fail;
13554 if (obj1) {
13555 {
13556 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13557 if (SWIG_arg_fail(2)) SWIG_fail;
13558 }
13559 }
13560 {
13561 if (!wxPyCheckForApp()) SWIG_fail;
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (bool)((wxSound const *)arg1)->Play(arg2);
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13570 }
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj;
13579 wxString *arg1 = 0 ;
13580 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13581 bool result;
13582 bool temp1 = false ;
13583 PyObject * obj0 = 0 ;
13584 PyObject * obj1 = 0 ;
13585 char *kwnames[] = {
13586 (char *) "filename",(char *) "flags", NULL
13587 };
13588
13589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13590 {
13591 arg1 = wxString_in_helper(obj0);
13592 if (arg1 == NULL) SWIG_fail;
13593 temp1 = true;
13594 }
13595 if (obj1) {
13596 {
13597 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13598 if (SWIG_arg_fail(2)) SWIG_fail;
13599 }
13600 }
13601 {
13602 if (!wxPyCheckForApp()) SWIG_fail;
13603 PyThreadState* __tstate = wxPyBeginAllowThreads();
13604 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13605
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 {
13610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13611 }
13612 {
13613 if (temp1)
13614 delete arg1;
13615 }
13616 return resultobj;
13617 fail:
13618 {
13619 if (temp1)
13620 delete arg1;
13621 }
13622 return NULL;
13623 }
13624
13625
13626 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 char *kwnames[] = {
13629 NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13633 {
13634 if (!wxPyCheckForApp()) SWIG_fail;
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 wxSound::Stop();
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 Py_INCREF(Py_None); resultobj = Py_None;
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13649 PyObject *obj;
13650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13651 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13652 Py_INCREF(obj);
13653 return Py_BuildValue((char *)"");
13654 }
13655 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13656 PyObject *resultobj;
13657 wxString *arg1 = 0 ;
13658 wxString *arg2 = 0 ;
13659 wxString *arg3 = 0 ;
13660 wxString *arg4 = 0 ;
13661 wxFileTypeInfo *result;
13662 bool temp1 = false ;
13663 bool temp2 = false ;
13664 bool temp3 = false ;
13665 bool temp4 = false ;
13666 PyObject * obj0 = 0 ;
13667 PyObject * obj1 = 0 ;
13668 PyObject * obj2 = 0 ;
13669 PyObject * obj3 = 0 ;
13670 char *kwnames[] = {
13671 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13672 };
13673
13674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13675 {
13676 arg1 = wxString_in_helper(obj0);
13677 if (arg1 == NULL) SWIG_fail;
13678 temp1 = true;
13679 }
13680 {
13681 arg2 = wxString_in_helper(obj1);
13682 if (arg2 == NULL) SWIG_fail;
13683 temp2 = true;
13684 }
13685 {
13686 arg3 = wxString_in_helper(obj2);
13687 if (arg3 == NULL) SWIG_fail;
13688 temp3 = true;
13689 }
13690 {
13691 arg4 = wxString_in_helper(obj3);
13692 if (arg4 == NULL) SWIG_fail;
13693 temp4 = true;
13694 }
13695 {
13696 PyThreadState* __tstate = wxPyBeginAllowThreads();
13697 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13698
13699 wxPyEndAllowThreads(__tstate);
13700 if (PyErr_Occurred()) SWIG_fail;
13701 }
13702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13703 {
13704 if (temp1)
13705 delete arg1;
13706 }
13707 {
13708 if (temp2)
13709 delete arg2;
13710 }
13711 {
13712 if (temp3)
13713 delete arg3;
13714 }
13715 {
13716 if (temp4)
13717 delete arg4;
13718 }
13719 return resultobj;
13720 fail:
13721 {
13722 if (temp1)
13723 delete arg1;
13724 }
13725 {
13726 if (temp2)
13727 delete arg2;
13728 }
13729 {
13730 if (temp3)
13731 delete arg3;
13732 }
13733 {
13734 if (temp4)
13735 delete arg4;
13736 }
13737 return NULL;
13738 }
13739
13740
13741 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj;
13743 wxArrayString *arg1 = 0 ;
13744 wxFileTypeInfo *result;
13745 bool temp1 = false ;
13746 PyObject * obj0 = 0 ;
13747 char *kwnames[] = {
13748 (char *) "sArray", NULL
13749 };
13750
13751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13752 {
13753 if (! PySequence_Check(obj0)) {
13754 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13755 SWIG_fail;
13756 }
13757 arg1 = new wxArrayString;
13758 temp1 = true;
13759 int i, len=PySequence_Length(obj0);
13760 for (i=0; i<len; i++) {
13761 PyObject* item = PySequence_GetItem(obj0, i);
13762 #if wxUSE_UNICODE
13763 PyObject* str = PyObject_Unicode(item);
13764 #else
13765 PyObject* str = PyObject_Str(item);
13766 #endif
13767 if (PyErr_Occurred()) SWIG_fail;
13768 arg1->Add(Py2wxString(str));
13769 Py_DECREF(item);
13770 Py_DECREF(str);
13771 }
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13776
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13781 {
13782 if (temp1) delete arg1;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp1) delete arg1;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj;
13795 wxFileTypeInfo *result;
13796 char *kwnames[] = {
13797 NULL
13798 };
13799
13800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13804
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13809 return resultobj;
13810 fail:
13811 return NULL;
13812 }
13813
13814
13815 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13816 PyObject *resultobj;
13817 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13818 bool result;
13819 PyObject * obj0 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "self", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13826 if (SWIG_arg_fail(1)) SWIG_fail;
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 {
13835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13836 }
13837 return resultobj;
13838 fail:
13839 return NULL;
13840 }
13841
13842
13843 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13844 PyObject *resultobj;
13845 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13846 wxString *arg2 = 0 ;
13847 int arg3 = (int) 0 ;
13848 bool temp2 = false ;
13849 PyObject * obj0 = 0 ;
13850 PyObject * obj1 = 0 ;
13851 PyObject * obj2 = 0 ;
13852 char *kwnames[] = {
13853 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13858 if (SWIG_arg_fail(1)) SWIG_fail;
13859 {
13860 arg2 = wxString_in_helper(obj1);
13861 if (arg2 == NULL) SWIG_fail;
13862 temp2 = true;
13863 }
13864 if (obj2) {
13865 {
13866 arg3 = (int)(SWIG_As_int(obj2));
13867 if (SWIG_arg_fail(3)) SWIG_fail;
13868 }
13869 }
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 Py_INCREF(Py_None); resultobj = Py_None;
13878 {
13879 if (temp2)
13880 delete arg2;
13881 }
13882 return resultobj;
13883 fail:
13884 {
13885 if (temp2)
13886 delete arg2;
13887 }
13888 return NULL;
13889 }
13890
13891
13892 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj;
13894 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13895 wxString *arg2 = 0 ;
13896 bool temp2 = false ;
13897 PyObject * obj0 = 0 ;
13898 PyObject * obj1 = 0 ;
13899 char *kwnames[] = {
13900 (char *) "self",(char *) "shortDesc", NULL
13901 };
13902
13903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13905 if (SWIG_arg_fail(1)) SWIG_fail;
13906 {
13907 arg2 = wxString_in_helper(obj1);
13908 if (arg2 == NULL) SWIG_fail;
13909 temp2 = true;
13910 }
13911 {
13912 PyThreadState* __tstate = wxPyBeginAllowThreads();
13913 (arg1)->SetShortDesc((wxString const &)*arg2);
13914
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 Py_INCREF(Py_None); resultobj = Py_None;
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return resultobj;
13924 fail:
13925 {
13926 if (temp2)
13927 delete arg2;
13928 }
13929 return NULL;
13930 }
13931
13932
13933 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj;
13935 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13936 wxString *result;
13937 PyObject * obj0 = 0 ;
13938 char *kwnames[] = {
13939 (char *) "self", NULL
13940 };
13941
13942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13944 if (SWIG_arg_fail(1)) SWIG_fail;
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 {
13948 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13949 result = (wxString *) &_result_ref;
13950 }
13951
13952 wxPyEndAllowThreads(__tstate);
13953 if (PyErr_Occurred()) SWIG_fail;
13954 }
13955 {
13956 #if wxUSE_UNICODE
13957 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13958 #else
13959 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13960 #endif
13961 }
13962 return resultobj;
13963 fail:
13964 return NULL;
13965 }
13966
13967
13968 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj;
13970 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13971 wxString *result;
13972 PyObject * obj0 = 0 ;
13973 char *kwnames[] = {
13974 (char *) "self", NULL
13975 };
13976
13977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13979 if (SWIG_arg_fail(1)) SWIG_fail;
13980 {
13981 PyThreadState* __tstate = wxPyBeginAllowThreads();
13982 {
13983 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13984 result = (wxString *) &_result_ref;
13985 }
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 {
13991 #if wxUSE_UNICODE
13992 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13993 #else
13994 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13995 #endif
13996 }
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj;
14005 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14006 wxString *result;
14007 PyObject * obj0 = 0 ;
14008 char *kwnames[] = {
14009 (char *) "self", NULL
14010 };
14011
14012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 {
14018 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14019 result = (wxString *) &_result_ref;
14020 }
14021
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 {
14026 #if wxUSE_UNICODE
14027 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14028 #else
14029 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14030 #endif
14031 }
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj;
14040 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14041 wxString *result;
14042 PyObject * obj0 = 0 ;
14043 char *kwnames[] = {
14044 (char *) "self", NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(1)) SWIG_fail;
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 {
14053 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14054 result = (wxString *) &_result_ref;
14055 }
14056
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 {
14061 #if wxUSE_UNICODE
14062 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14063 #else
14064 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14065 #endif
14066 }
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj;
14075 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14076 wxString *result;
14077 PyObject * obj0 = 0 ;
14078 char *kwnames[] = {
14079 (char *) "self", NULL
14080 };
14081
14082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14084 if (SWIG_arg_fail(1)) SWIG_fail;
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 {
14088 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14089 result = (wxString *) &_result_ref;
14090 }
14091
14092 wxPyEndAllowThreads(__tstate);
14093 if (PyErr_Occurred()) SWIG_fail;
14094 }
14095 {
14096 #if wxUSE_UNICODE
14097 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14098 #else
14099 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14100 #endif
14101 }
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14109 PyObject *resultobj;
14110 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14111 wxArrayString *result;
14112 PyObject * obj0 = 0 ;
14113 char *kwnames[] = {
14114 (char *) "self", NULL
14115 };
14116
14117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14119 if (SWIG_arg_fail(1)) SWIG_fail;
14120 {
14121 PyThreadState* __tstate = wxPyBeginAllowThreads();
14122 {
14123 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14124 result = (wxArrayString *) &_result_ref;
14125 }
14126
14127 wxPyEndAllowThreads(__tstate);
14128 if (PyErr_Occurred()) SWIG_fail;
14129 }
14130 {
14131 resultobj = wxArrayString2PyList_helper(*result);
14132 }
14133 return resultobj;
14134 fail:
14135 return NULL;
14136 }
14137
14138
14139 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14140 PyObject *resultobj;
14141 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14142 int result;
14143 PyObject * obj0 = 0 ;
14144 char *kwnames[] = {
14145 (char *) "self", NULL
14146 };
14147
14148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14150 if (SWIG_arg_fail(1)) SWIG_fail;
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14154
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 {
14159 resultobj = SWIG_From_int((int)(result));
14160 }
14161 return resultobj;
14162 fail:
14163 return NULL;
14164 }
14165
14166
14167 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14168 PyObject *resultobj;
14169 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14170 wxString *result;
14171 PyObject * obj0 = 0 ;
14172 char *kwnames[] = {
14173 (char *) "self", NULL
14174 };
14175
14176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14178 if (SWIG_arg_fail(1)) SWIG_fail;
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 {
14182 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14183 result = (wxString *) &_result_ref;
14184 }
14185
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 {
14190 #if wxUSE_UNICODE
14191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14192 #else
14193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14194 #endif
14195 }
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14203 PyObject *resultobj;
14204 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14205 int result;
14206 PyObject * obj0 = 0 ;
14207 char *kwnames[] = {
14208 (char *) "self", NULL
14209 };
14210
14211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14213 if (SWIG_arg_fail(1)) SWIG_fail;
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 resultobj = SWIG_From_int((int)(result));
14223 }
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14231 PyObject *obj;
14232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14233 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14234 Py_INCREF(obj);
14235 return Py_BuildValue((char *)"");
14236 }
14237 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj;
14239 wxFileTypeInfo *arg1 = 0 ;
14240 wxFileType *result;
14241 PyObject * obj0 = 0 ;
14242 char *kwnames[] = {
14243 (char *) "ftInfo", NULL
14244 };
14245
14246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14247 {
14248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14249 if (SWIG_arg_fail(1)) SWIG_fail;
14250 if (arg1 == NULL) {
14251 SWIG_null_ref("wxFileTypeInfo");
14252 }
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 }
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxFileType *arg1 = (wxFileType *) 0 ;
14272 PyObject * obj0 = 0 ;
14273 char *kwnames[] = {
14274 (char *) "self", NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14279 if (SWIG_arg_fail(1)) SWIG_fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 delete arg1;
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 Py_INCREF(Py_None); resultobj = Py_None;
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj;
14296 wxFileType *arg1 = (wxFileType *) 0 ;
14297 PyObject *result;
14298 PyObject * obj0 = 0 ;
14299 char *kwnames[] = {
14300 (char *) "self", NULL
14301 };
14302
14303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14305 if (SWIG_arg_fail(1)) SWIG_fail;
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (PyObject *)wxFileType_GetMimeType(arg1);
14309
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 resultobj = result;
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj;
14322 wxFileType *arg1 = (wxFileType *) 0 ;
14323 PyObject *result;
14324 PyObject * obj0 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14335
14336 wxPyEndAllowThreads(__tstate);
14337 if (PyErr_Occurred()) SWIG_fail;
14338 }
14339 resultobj = result;
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxFileType *arg1 = (wxFileType *) 0 ;
14349 PyObject *result;
14350 PyObject * obj0 = 0 ;
14351 char *kwnames[] = {
14352 (char *) "self", NULL
14353 };
14354
14355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14357 if (SWIG_arg_fail(1)) SWIG_fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (PyObject *)wxFileType_GetExtensions(arg1);
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = result;
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj;
14374 wxFileType *arg1 = (wxFileType *) 0 ;
14375 wxIcon *result;
14376 PyObject * obj0 = 0 ;
14377 char *kwnames[] = {
14378 (char *) "self", NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14383 if (SWIG_arg_fail(1)) SWIG_fail;
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (wxIcon *)wxFileType_GetIcon(arg1);
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14392 return resultobj;
14393 fail:
14394 return NULL;
14395 }
14396
14397
14398 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14399 PyObject *resultobj;
14400 wxFileType *arg1 = (wxFileType *) 0 ;
14401 PyObject *result;
14402 PyObject * obj0 = 0 ;
14403 char *kwnames[] = {
14404 (char *) "self", NULL
14405 };
14406
14407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14409 if (SWIG_arg_fail(1)) SWIG_fail;
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14413
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = result;
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14425 PyObject *resultobj;
14426 wxFileType *arg1 = (wxFileType *) 0 ;
14427 PyObject *result;
14428 PyObject * obj0 = 0 ;
14429 char *kwnames[] = {
14430 (char *) "self", NULL
14431 };
14432
14433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14435 if (SWIG_arg_fail(1)) SWIG_fail;
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (PyObject *)wxFileType_GetDescription(arg1);
14439
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = result;
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj;
14452 wxFileType *arg1 = (wxFileType *) 0 ;
14453 wxString *arg2 = 0 ;
14454 wxString const &arg3_defvalue = wxPyEmptyString ;
14455 wxString *arg3 = (wxString *) &arg3_defvalue ;
14456 PyObject *result;
14457 bool temp2 = false ;
14458 bool temp3 = false ;
14459 PyObject * obj0 = 0 ;
14460 PyObject * obj1 = 0 ;
14461 PyObject * obj2 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 arg2 = wxString_in_helper(obj1);
14471 if (arg2 == NULL) SWIG_fail;
14472 temp2 = true;
14473 }
14474 if (obj2) {
14475 {
14476 arg3 = wxString_in_helper(obj2);
14477 if (arg3 == NULL) SWIG_fail;
14478 temp3 = true;
14479 }
14480 }
14481 {
14482 PyThreadState* __tstate = wxPyBeginAllowThreads();
14483 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14484
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 resultobj = result;
14489 {
14490 if (temp2)
14491 delete arg2;
14492 }
14493 {
14494 if (temp3)
14495 delete arg3;
14496 }
14497 return resultobj;
14498 fail:
14499 {
14500 if (temp2)
14501 delete arg2;
14502 }
14503 {
14504 if (temp3)
14505 delete arg3;
14506 }
14507 return NULL;
14508 }
14509
14510
14511 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14512 PyObject *resultobj;
14513 wxFileType *arg1 = (wxFileType *) 0 ;
14514 wxString *arg2 = 0 ;
14515 wxString const &arg3_defvalue = wxPyEmptyString ;
14516 wxString *arg3 = (wxString *) &arg3_defvalue ;
14517 PyObject *result;
14518 bool temp2 = false ;
14519 bool temp3 = false ;
14520 PyObject * obj0 = 0 ;
14521 PyObject * obj1 = 0 ;
14522 PyObject * obj2 = 0 ;
14523 char *kwnames[] = {
14524 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14525 };
14526
14527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14529 if (SWIG_arg_fail(1)) SWIG_fail;
14530 {
14531 arg2 = wxString_in_helper(obj1);
14532 if (arg2 == NULL) SWIG_fail;
14533 temp2 = true;
14534 }
14535 if (obj2) {
14536 {
14537 arg3 = wxString_in_helper(obj2);
14538 if (arg3 == NULL) SWIG_fail;
14539 temp3 = true;
14540 }
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14545
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = result;
14550 {
14551 if (temp2)
14552 delete arg2;
14553 }
14554 {
14555 if (temp3)
14556 delete arg3;
14557 }
14558 return resultobj;
14559 fail:
14560 {
14561 if (temp2)
14562 delete arg2;
14563 }
14564 {
14565 if (temp3)
14566 delete arg3;
14567 }
14568 return NULL;
14569 }
14570
14571
14572 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj;
14574 wxFileType *arg1 = (wxFileType *) 0 ;
14575 wxString *arg2 = 0 ;
14576 wxString const &arg3_defvalue = wxPyEmptyString ;
14577 wxString *arg3 = (wxString *) &arg3_defvalue ;
14578 PyObject *result;
14579 bool temp2 = false ;
14580 bool temp3 = false ;
14581 PyObject * obj0 = 0 ;
14582 PyObject * obj1 = 0 ;
14583 PyObject * obj2 = 0 ;
14584 char *kwnames[] = {
14585 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14586 };
14587
14588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14590 if (SWIG_arg_fail(1)) SWIG_fail;
14591 {
14592 arg2 = wxString_in_helper(obj1);
14593 if (arg2 == NULL) SWIG_fail;
14594 temp2 = true;
14595 }
14596 if (obj2) {
14597 {
14598 arg3 = wxString_in_helper(obj2);
14599 if (arg3 == NULL) SWIG_fail;
14600 temp3 = true;
14601 }
14602 }
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 resultobj = result;
14611 {
14612 if (temp2)
14613 delete arg2;
14614 }
14615 {
14616 if (temp3)
14617 delete arg3;
14618 }
14619 return resultobj;
14620 fail:
14621 {
14622 if (temp2)
14623 delete arg2;
14624 }
14625 {
14626 if (temp3)
14627 delete arg3;
14628 }
14629 return NULL;
14630 }
14631
14632
14633 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj;
14635 wxFileType *arg1 = (wxFileType *) 0 ;
14636 wxString *arg2 = 0 ;
14637 wxString *arg3 = 0 ;
14638 bool arg4 = (bool) true ;
14639 bool result;
14640 bool temp2 = false ;
14641 bool temp3 = false ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 PyObject * obj2 = 0 ;
14645 PyObject * obj3 = 0 ;
14646 char *kwnames[] = {
14647 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14648 };
14649
14650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14652 if (SWIG_arg_fail(1)) SWIG_fail;
14653 {
14654 arg2 = wxString_in_helper(obj1);
14655 if (arg2 == NULL) SWIG_fail;
14656 temp2 = true;
14657 }
14658 {
14659 arg3 = wxString_in_helper(obj2);
14660 if (arg3 == NULL) SWIG_fail;
14661 temp3 = true;
14662 }
14663 if (obj3) {
14664 {
14665 arg4 = (bool)(SWIG_As_bool(obj3));
14666 if (SWIG_arg_fail(4)) SWIG_fail;
14667 }
14668 }
14669 {
14670 PyThreadState* __tstate = wxPyBeginAllowThreads();
14671 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14672
14673 wxPyEndAllowThreads(__tstate);
14674 if (PyErr_Occurred()) SWIG_fail;
14675 }
14676 {
14677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14678 }
14679 {
14680 if (temp2)
14681 delete arg2;
14682 }
14683 {
14684 if (temp3)
14685 delete arg3;
14686 }
14687 return resultobj;
14688 fail:
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 {
14694 if (temp3)
14695 delete arg3;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj;
14703 wxFileType *arg1 = (wxFileType *) 0 ;
14704 wxString const &arg2_defvalue = wxPyEmptyString ;
14705 wxString *arg2 = (wxString *) &arg2_defvalue ;
14706 int arg3 = (int) 0 ;
14707 bool result;
14708 bool temp2 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char *kwnames[] = {
14713 (char *) "self",(char *) "cmd",(char *) "index", NULL
14714 };
14715
14716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14718 if (SWIG_arg_fail(1)) SWIG_fail;
14719 if (obj1) {
14720 {
14721 arg2 = wxString_in_helper(obj1);
14722 if (arg2 == NULL) SWIG_fail;
14723 temp2 = true;
14724 }
14725 }
14726 if (obj2) {
14727 {
14728 arg3 = (int)(SWIG_As_int(obj2));
14729 if (SWIG_arg_fail(3)) SWIG_fail;
14730 }
14731 }
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14735
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 {
14740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14741 }
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 return resultobj;
14747 fail:
14748 {
14749 if (temp2)
14750 delete arg2;
14751 }
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj;
14758 wxFileType *arg1 = (wxFileType *) 0 ;
14759 bool result;
14760 PyObject * obj0 = 0 ;
14761 char *kwnames[] = {
14762 (char *) "self", NULL
14763 };
14764
14765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14767 if (SWIG_arg_fail(1)) SWIG_fail;
14768 {
14769 PyThreadState* __tstate = wxPyBeginAllowThreads();
14770 result = (bool)(arg1)->Unassociate();
14771
14772 wxPyEndAllowThreads(__tstate);
14773 if (PyErr_Occurred()) SWIG_fail;
14774 }
14775 {
14776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14777 }
14778 return resultobj;
14779 fail:
14780 return NULL;
14781 }
14782
14783
14784 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14785 PyObject *resultobj;
14786 wxString *arg1 = 0 ;
14787 wxString *arg2 = 0 ;
14788 wxString const &arg3_defvalue = wxPyEmptyString ;
14789 wxString *arg3 = (wxString *) &arg3_defvalue ;
14790 wxString result;
14791 bool temp1 = false ;
14792 bool temp2 = false ;
14793 bool temp3 = false ;
14794 PyObject * obj0 = 0 ;
14795 PyObject * obj1 = 0 ;
14796 PyObject * obj2 = 0 ;
14797 char *kwnames[] = {
14798 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14799 };
14800
14801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14802 {
14803 arg1 = wxString_in_helper(obj0);
14804 if (arg1 == NULL) SWIG_fail;
14805 temp1 = true;
14806 }
14807 {
14808 arg2 = wxString_in_helper(obj1);
14809 if (arg2 == NULL) SWIG_fail;
14810 temp2 = true;
14811 }
14812 if (obj2) {
14813 {
14814 arg3 = wxString_in_helper(obj2);
14815 if (arg3 == NULL) SWIG_fail;
14816 temp3 = true;
14817 }
14818 }
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14822
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 #if wxUSE_UNICODE
14828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14829 #else
14830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14831 #endif
14832 }
14833 {
14834 if (temp1)
14835 delete arg1;
14836 }
14837 {
14838 if (temp2)
14839 delete arg2;
14840 }
14841 {
14842 if (temp3)
14843 delete arg3;
14844 }
14845 return resultobj;
14846 fail:
14847 {
14848 if (temp1)
14849 delete arg1;
14850 }
14851 {
14852 if (temp2)
14853 delete arg2;
14854 }
14855 {
14856 if (temp3)
14857 delete arg3;
14858 }
14859 return NULL;
14860 }
14861
14862
14863 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14864 PyObject *obj;
14865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14866 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14867 Py_INCREF(obj);
14868 return Py_BuildValue((char *)"");
14869 }
14870 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14871 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14872 return 1;
14873 }
14874
14875
14876 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14877 PyObject *pyobj;
14878
14879 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14880 return pyobj;
14881 }
14882
14883
14884 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14885 PyObject *resultobj;
14886 wxString *arg1 = 0 ;
14887 wxString *arg2 = 0 ;
14888 bool result;
14889 bool temp1 = false ;
14890 bool temp2 = false ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 char *kwnames[] = {
14894 (char *) "mimeType",(char *) "wildcard", NULL
14895 };
14896
14897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14898 {
14899 arg1 = wxString_in_helper(obj0);
14900 if (arg1 == NULL) SWIG_fail;
14901 temp1 = true;
14902 }
14903 {
14904 arg2 = wxString_in_helper(obj1);
14905 if (arg2 == NULL) SWIG_fail;
14906 temp2 = true;
14907 }
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 {
14919 if (temp1)
14920 delete arg1;
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp1)
14930 delete arg1;
14931 }
14932 {
14933 if (temp2)
14934 delete arg2;
14935 }
14936 return NULL;
14937 }
14938
14939
14940 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14941 PyObject *resultobj;
14942 wxMimeTypesManager *result;
14943 char *kwnames[] = {
14944 NULL
14945 };
14946
14947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14951
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14963 PyObject *resultobj;
14964 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14965 int arg2 = (int) wxMAILCAP_ALL ;
14966 wxString const &arg3_defvalue = wxPyEmptyString ;
14967 wxString *arg3 = (wxString *) &arg3_defvalue ;
14968 bool temp3 = false ;
14969 PyObject * obj0 = 0 ;
14970 PyObject * obj1 = 0 ;
14971 PyObject * obj2 = 0 ;
14972 char *kwnames[] = {
14973 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14978 if (SWIG_arg_fail(1)) SWIG_fail;
14979 if (obj1) {
14980 {
14981 arg2 = (int)(SWIG_As_int(obj1));
14982 if (SWIG_arg_fail(2)) SWIG_fail;
14983 }
14984 }
14985 if (obj2) {
14986 {
14987 arg3 = wxString_in_helper(obj2);
14988 if (arg3 == NULL) SWIG_fail;
14989 temp3 = true;
14990 }
14991 }
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14995
14996 wxPyEndAllowThreads(__tstate);
14997 if (PyErr_Occurred()) SWIG_fail;
14998 }
14999 Py_INCREF(Py_None); resultobj = Py_None;
15000 {
15001 if (temp3)
15002 delete arg3;
15003 }
15004 return resultobj;
15005 fail:
15006 {
15007 if (temp3)
15008 delete arg3;
15009 }
15010 return NULL;
15011 }
15012
15013
15014 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj;
15016 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15017 PyObject * obj0 = 0 ;
15018 char *kwnames[] = {
15019 (char *) "self", NULL
15020 };
15021
15022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15024 if (SWIG_arg_fail(1)) SWIG_fail;
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 (arg1)->ClearData();
15028
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 Py_INCREF(Py_None); resultobj = Py_None;
15033 return resultobj;
15034 fail:
15035 return NULL;
15036 }
15037
15038
15039 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15040 PyObject *resultobj;
15041 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15042 wxString *arg2 = 0 ;
15043 wxFileType *result;
15044 bool temp2 = false ;
15045 PyObject * obj0 = 0 ;
15046 PyObject * obj1 = 0 ;
15047 char *kwnames[] = {
15048 (char *) "self",(char *) "ext", NULL
15049 };
15050
15051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15053 if (SWIG_arg_fail(1)) SWIG_fail;
15054 {
15055 arg2 = wxString_in_helper(obj1);
15056 if (arg2 == NULL) SWIG_fail;
15057 temp2 = true;
15058 }
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15067 {
15068 if (temp2)
15069 delete arg2;
15070 }
15071 return resultobj;
15072 fail:
15073 {
15074 if (temp2)
15075 delete arg2;
15076 }
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15084 wxString *arg2 = 0 ;
15085 wxFileType *result;
15086 bool temp2 = false ;
15087 PyObject * obj0 = 0 ;
15088 PyObject * obj1 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "self",(char *) "mimeType", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(1)) SWIG_fail;
15096 {
15097 arg2 = wxString_in_helper(obj1);
15098 if (arg2 == NULL) SWIG_fail;
15099 temp2 = true;
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15104
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15109 {
15110 if (temp2)
15111 delete arg2;
15112 }
15113 return resultobj;
15114 fail:
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 return NULL;
15120 }
15121
15122
15123 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj;
15125 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15126 wxString *arg2 = 0 ;
15127 bool arg3 = (bool) false ;
15128 bool result;
15129 bool temp2 = false ;
15130 PyObject * obj0 = 0 ;
15131 PyObject * obj1 = 0 ;
15132 PyObject * obj2 = 0 ;
15133 char *kwnames[] = {
15134 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15135 };
15136
15137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15139 if (SWIG_arg_fail(1)) SWIG_fail;
15140 {
15141 arg2 = wxString_in_helper(obj1);
15142 if (arg2 == NULL) SWIG_fail;
15143 temp2 = true;
15144 }
15145 if (obj2) {
15146 {
15147 arg3 = (bool)(SWIG_As_bool(obj2));
15148 if (SWIG_arg_fail(3)) SWIG_fail;
15149 }
15150 }
15151 {
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15154
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 {
15159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15160 }
15161 {
15162 if (temp2)
15163 delete arg2;
15164 }
15165 return resultobj;
15166 fail:
15167 {
15168 if (temp2)
15169 delete arg2;
15170 }
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15178 wxString *arg2 = 0 ;
15179 bool result;
15180 bool temp2 = false ;
15181 PyObject * obj0 = 0 ;
15182 PyObject * obj1 = 0 ;
15183 char *kwnames[] = {
15184 (char *) "self",(char *) "filename", NULL
15185 };
15186
15187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15189 if (SWIG_arg_fail(1)) SWIG_fail;
15190 {
15191 arg2 = wxString_in_helper(obj1);
15192 if (arg2 == NULL) SWIG_fail;
15193 temp2 = true;
15194 }
15195 {
15196 PyThreadState* __tstate = wxPyBeginAllowThreads();
15197 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15198
15199 wxPyEndAllowThreads(__tstate);
15200 if (PyErr_Occurred()) SWIG_fail;
15201 }
15202 {
15203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15204 }
15205 {
15206 if (temp2)
15207 delete arg2;
15208 }
15209 return resultobj;
15210 fail:
15211 {
15212 if (temp2)
15213 delete arg2;
15214 }
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15222 PyObject *result;
15223 PyObject * obj0 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self", NULL
15226 };
15227
15228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15230 if (SWIG_arg_fail(1)) SWIG_fail;
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15234
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 resultobj = result;
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15246 PyObject *resultobj;
15247 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15248 wxFileTypeInfo *arg2 = 0 ;
15249 PyObject * obj0 = 0 ;
15250 PyObject * obj1 = 0 ;
15251 char *kwnames[] = {
15252 (char *) "self",(char *) "ft", NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15257 if (SWIG_arg_fail(1)) SWIG_fail;
15258 {
15259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15260 if (SWIG_arg_fail(2)) SWIG_fail;
15261 if (arg2 == NULL) {
15262 SWIG_null_ref("wxFileTypeInfo");
15263 }
15264 if (SWIG_arg_fail(2)) SWIG_fail;
15265 }
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 Py_INCREF(Py_None); resultobj = Py_None;
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15281 PyObject *resultobj;
15282 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15283 wxFileTypeInfo *arg2 = 0 ;
15284 wxFileType *result;
15285 PyObject * obj0 = 0 ;
15286 PyObject * obj1 = 0 ;
15287 char *kwnames[] = {
15288 (char *) "self",(char *) "ftInfo", NULL
15289 };
15290
15291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(1)) SWIG_fail;
15294 {
15295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15296 if (SWIG_arg_fail(2)) SWIG_fail;
15297 if (arg2 == NULL) {
15298 SWIG_null_ref("wxFileTypeInfo");
15299 }
15300 if (SWIG_arg_fail(2)) SWIG_fail;
15301 }
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15305
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj;
15318 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15319 wxFileType *arg2 = (wxFileType *) 0 ;
15320 bool result;
15321 PyObject * obj0 = 0 ;
15322 PyObject * obj1 = 0 ;
15323 char *kwnames[] = {
15324 (char *) "self",(char *) "ft", NULL
15325 };
15326
15327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(1)) SWIG_fail;
15330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15331 if (SWIG_arg_fail(2)) SWIG_fail;
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 result = (bool)(arg1)->Unassociate(arg2);
15335
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 {
15340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15341 }
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 delete arg1;
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 Py_INCREF(Py_None); resultobj = Py_None;
15367 return resultobj;
15368 fail:
15369 return NULL;
15370 }
15371
15372
15373 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15374 PyObject *obj;
15375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15376 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15377 Py_INCREF(obj);
15378 return Py_BuildValue((char *)"");
15379 }
15380 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15381 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15382 return 1;
15383 }
15384
15385
15386 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15387 PyObject *pyobj;
15388
15389 {
15390 #if wxUSE_UNICODE
15391 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15392 #else
15393 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15394 #endif
15395 }
15396 return pyobj;
15397 }
15398
15399
15400 static int _wrap_ART_MENU_set(PyObject *) {
15401 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15402 return 1;
15403 }
15404
15405
15406 static PyObject *_wrap_ART_MENU_get(void) {
15407 PyObject *pyobj;
15408
15409 {
15410 #if wxUSE_UNICODE
15411 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15412 #else
15413 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15414 #endif
15415 }
15416 return pyobj;
15417 }
15418
15419
15420 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15421 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15422 return 1;
15423 }
15424
15425
15426 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15427 PyObject *pyobj;
15428
15429 {
15430 #if wxUSE_UNICODE
15431 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15432 #else
15433 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15434 #endif
15435 }
15436 return pyobj;
15437 }
15438
15439
15440 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15441 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15442 return 1;
15443 }
15444
15445
15446 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15447 PyObject *pyobj;
15448
15449 {
15450 #if wxUSE_UNICODE
15451 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15452 #else
15453 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15454 #endif
15455 }
15456 return pyobj;
15457 }
15458
15459
15460 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15461 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15462 return 1;
15463 }
15464
15465
15466 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15467 PyObject *pyobj;
15468
15469 {
15470 #if wxUSE_UNICODE
15471 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15472 #else
15473 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15474 #endif
15475 }
15476 return pyobj;
15477 }
15478
15479
15480 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15481 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15482 return 1;
15483 }
15484
15485
15486 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15487 PyObject *pyobj;
15488
15489 {
15490 #if wxUSE_UNICODE
15491 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15492 #else
15493 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15494 #endif
15495 }
15496 return pyobj;
15497 }
15498
15499
15500 static int _wrap_ART_BUTTON_set(PyObject *) {
15501 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15502 return 1;
15503 }
15504
15505
15506 static PyObject *_wrap_ART_BUTTON_get(void) {
15507 PyObject *pyobj;
15508
15509 {
15510 #if wxUSE_UNICODE
15511 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15512 #else
15513 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15514 #endif
15515 }
15516 return pyobj;
15517 }
15518
15519
15520 static int _wrap_ART_OTHER_set(PyObject *) {
15521 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15522 return 1;
15523 }
15524
15525
15526 static PyObject *_wrap_ART_OTHER_get(void) {
15527 PyObject *pyobj;
15528
15529 {
15530 #if wxUSE_UNICODE
15531 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15532 #else
15533 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15534 #endif
15535 }
15536 return pyobj;
15537 }
15538
15539
15540 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15541 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15542 return 1;
15543 }
15544
15545
15546 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15547 PyObject *pyobj;
15548
15549 {
15550 #if wxUSE_UNICODE
15551 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15552 #else
15553 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15554 #endif
15555 }
15556 return pyobj;
15557 }
15558
15559
15560 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15561 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15562 return 1;
15563 }
15564
15565
15566 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15567 PyObject *pyobj;
15568
15569 {
15570 #if wxUSE_UNICODE
15571 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15572 #else
15573 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15574 #endif
15575 }
15576 return pyobj;
15577 }
15578
15579
15580 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15581 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15582 return 1;
15583 }
15584
15585
15586 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15587 PyObject *pyobj;
15588
15589 {
15590 #if wxUSE_UNICODE
15591 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15592 #else
15593 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15594 #endif
15595 }
15596 return pyobj;
15597 }
15598
15599
15600 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15601 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15602 return 1;
15603 }
15604
15605
15606 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15607 PyObject *pyobj;
15608
15609 {
15610 #if wxUSE_UNICODE
15611 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15612 #else
15613 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15614 #endif
15615 }
15616 return pyobj;
15617 }
15618
15619
15620 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15621 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15622 return 1;
15623 }
15624
15625
15626 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15627 PyObject *pyobj;
15628
15629 {
15630 #if wxUSE_UNICODE
15631 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15632 #else
15633 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15634 #endif
15635 }
15636 return pyobj;
15637 }
15638
15639
15640 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15641 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15642 return 1;
15643 }
15644
15645
15646 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15647 PyObject *pyobj;
15648
15649 {
15650 #if wxUSE_UNICODE
15651 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15652 #else
15653 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15654 #endif
15655 }
15656 return pyobj;
15657 }
15658
15659
15660 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15661 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15662 return 1;
15663 }
15664
15665
15666 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15667 PyObject *pyobj;
15668
15669 {
15670 #if wxUSE_UNICODE
15671 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15672 #else
15673 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15674 #endif
15675 }
15676 return pyobj;
15677 }
15678
15679
15680 static int _wrap_ART_GO_BACK_set(PyObject *) {
15681 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15682 return 1;
15683 }
15684
15685
15686 static PyObject *_wrap_ART_GO_BACK_get(void) {
15687 PyObject *pyobj;
15688
15689 {
15690 #if wxUSE_UNICODE
15691 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15692 #else
15693 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15694 #endif
15695 }
15696 return pyobj;
15697 }
15698
15699
15700 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15701 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15702 return 1;
15703 }
15704
15705
15706 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15707 PyObject *pyobj;
15708
15709 {
15710 #if wxUSE_UNICODE
15711 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15712 #else
15713 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15714 #endif
15715 }
15716 return pyobj;
15717 }
15718
15719
15720 static int _wrap_ART_GO_UP_set(PyObject *) {
15721 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15722 return 1;
15723 }
15724
15725
15726 static PyObject *_wrap_ART_GO_UP_get(void) {
15727 PyObject *pyobj;
15728
15729 {
15730 #if wxUSE_UNICODE
15731 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15732 #else
15733 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15734 #endif
15735 }
15736 return pyobj;
15737 }
15738
15739
15740 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15741 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15742 return 1;
15743 }
15744
15745
15746 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15747 PyObject *pyobj;
15748
15749 {
15750 #if wxUSE_UNICODE
15751 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15752 #else
15753 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15754 #endif
15755 }
15756 return pyobj;
15757 }
15758
15759
15760 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15761 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15762 return 1;
15763 }
15764
15765
15766 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15767 PyObject *pyobj;
15768
15769 {
15770 #if wxUSE_UNICODE
15771 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15772 #else
15773 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15774 #endif
15775 }
15776 return pyobj;
15777 }
15778
15779
15780 static int _wrap_ART_GO_HOME_set(PyObject *) {
15781 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15782 return 1;
15783 }
15784
15785
15786 static PyObject *_wrap_ART_GO_HOME_get(void) {
15787 PyObject *pyobj;
15788
15789 {
15790 #if wxUSE_UNICODE
15791 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15792 #else
15793 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15794 #endif
15795 }
15796 return pyobj;
15797 }
15798
15799
15800 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15801 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15802 return 1;
15803 }
15804
15805
15806 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15807 PyObject *pyobj;
15808
15809 {
15810 #if wxUSE_UNICODE
15811 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15812 #else
15813 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15814 #endif
15815 }
15816 return pyobj;
15817 }
15818
15819
15820 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15821 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15822 return 1;
15823 }
15824
15825
15826 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15827 PyObject *pyobj;
15828
15829 {
15830 #if wxUSE_UNICODE
15831 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15832 #else
15833 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15834 #endif
15835 }
15836 return pyobj;
15837 }
15838
15839
15840 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15841 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15842 return 1;
15843 }
15844
15845
15846 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15847 PyObject *pyobj;
15848
15849 {
15850 #if wxUSE_UNICODE
15851 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15852 #else
15853 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15854 #endif
15855 }
15856 return pyobj;
15857 }
15858
15859
15860 static int _wrap_ART_PRINT_set(PyObject *) {
15861 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15862 return 1;
15863 }
15864
15865
15866 static PyObject *_wrap_ART_PRINT_get(void) {
15867 PyObject *pyobj;
15868
15869 {
15870 #if wxUSE_UNICODE
15871 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15872 #else
15873 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15874 #endif
15875 }
15876 return pyobj;
15877 }
15878
15879
15880 static int _wrap_ART_HELP_set(PyObject *) {
15881 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15882 return 1;
15883 }
15884
15885
15886 static PyObject *_wrap_ART_HELP_get(void) {
15887 PyObject *pyobj;
15888
15889 {
15890 #if wxUSE_UNICODE
15891 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15892 #else
15893 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15894 #endif
15895 }
15896 return pyobj;
15897 }
15898
15899
15900 static int _wrap_ART_TIP_set(PyObject *) {
15901 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15902 return 1;
15903 }
15904
15905
15906 static PyObject *_wrap_ART_TIP_get(void) {
15907 PyObject *pyobj;
15908
15909 {
15910 #if wxUSE_UNICODE
15911 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15912 #else
15913 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15914 #endif
15915 }
15916 return pyobj;
15917 }
15918
15919
15920 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15921 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15922 return 1;
15923 }
15924
15925
15926 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15927 PyObject *pyobj;
15928
15929 {
15930 #if wxUSE_UNICODE
15931 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15932 #else
15933 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15934 #endif
15935 }
15936 return pyobj;
15937 }
15938
15939
15940 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15941 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15942 return 1;
15943 }
15944
15945
15946 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15947 PyObject *pyobj;
15948
15949 {
15950 #if wxUSE_UNICODE
15951 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15952 #else
15953 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15954 #endif
15955 }
15956 return pyobj;
15957 }
15958
15959
15960 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15961 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15962 return 1;
15963 }
15964
15965
15966 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15967 PyObject *pyobj;
15968
15969 {
15970 #if wxUSE_UNICODE
15971 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15972 #else
15973 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15974 #endif
15975 }
15976 return pyobj;
15977 }
15978
15979
15980 static int _wrap_ART_HARDDISK_set(PyObject *) {
15981 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15982 return 1;
15983 }
15984
15985
15986 static PyObject *_wrap_ART_HARDDISK_get(void) {
15987 PyObject *pyobj;
15988
15989 {
15990 #if wxUSE_UNICODE
15991 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15992 #else
15993 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15994 #endif
15995 }
15996 return pyobj;
15997 }
15998
15999
16000 static int _wrap_ART_FLOPPY_set(PyObject *) {
16001 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16002 return 1;
16003 }
16004
16005
16006 static PyObject *_wrap_ART_FLOPPY_get(void) {
16007 PyObject *pyobj;
16008
16009 {
16010 #if wxUSE_UNICODE
16011 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16012 #else
16013 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16014 #endif
16015 }
16016 return pyobj;
16017 }
16018
16019
16020 static int _wrap_ART_CDROM_set(PyObject *) {
16021 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16022 return 1;
16023 }
16024
16025
16026 static PyObject *_wrap_ART_CDROM_get(void) {
16027 PyObject *pyobj;
16028
16029 {
16030 #if wxUSE_UNICODE
16031 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16032 #else
16033 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16034 #endif
16035 }
16036 return pyobj;
16037 }
16038
16039
16040 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16041 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16042 return 1;
16043 }
16044
16045
16046 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16047 PyObject *pyobj;
16048
16049 {
16050 #if wxUSE_UNICODE
16051 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16052 #else
16053 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16054 #endif
16055 }
16056 return pyobj;
16057 }
16058
16059
16060 static int _wrap_ART_FOLDER_set(PyObject *) {
16061 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16062 return 1;
16063 }
16064
16065
16066 static PyObject *_wrap_ART_FOLDER_get(void) {
16067 PyObject *pyobj;
16068
16069 {
16070 #if wxUSE_UNICODE
16071 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16072 #else
16073 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16074 #endif
16075 }
16076 return pyobj;
16077 }
16078
16079
16080 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16081 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16082 return 1;
16083 }
16084
16085
16086 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16087 PyObject *pyobj;
16088
16089 {
16090 #if wxUSE_UNICODE
16091 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16092 #else
16093 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16094 #endif
16095 }
16096 return pyobj;
16097 }
16098
16099
16100 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16101 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16102 return 1;
16103 }
16104
16105
16106 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16107 PyObject *pyobj;
16108
16109 {
16110 #if wxUSE_UNICODE
16111 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16112 #else
16113 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16114 #endif
16115 }
16116 return pyobj;
16117 }
16118
16119
16120 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16121 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16122 return 1;
16123 }
16124
16125
16126 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16127 PyObject *pyobj;
16128
16129 {
16130 #if wxUSE_UNICODE
16131 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16132 #else
16133 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16134 #endif
16135 }
16136 return pyobj;
16137 }
16138
16139
16140 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16141 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16142 return 1;
16143 }
16144
16145
16146 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16147 PyObject *pyobj;
16148
16149 {
16150 #if wxUSE_UNICODE
16151 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16152 #else
16153 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16154 #endif
16155 }
16156 return pyobj;
16157 }
16158
16159
16160 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16161 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16162 return 1;
16163 }
16164
16165
16166 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16167 PyObject *pyobj;
16168
16169 {
16170 #if wxUSE_UNICODE
16171 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16172 #else
16173 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16174 #endif
16175 }
16176 return pyobj;
16177 }
16178
16179
16180 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16181 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16182 return 1;
16183 }
16184
16185
16186 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16187 PyObject *pyobj;
16188
16189 {
16190 #if wxUSE_UNICODE
16191 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16192 #else
16193 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16194 #endif
16195 }
16196 return pyobj;
16197 }
16198
16199
16200 static int _wrap_ART_ERROR_set(PyObject *) {
16201 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16202 return 1;
16203 }
16204
16205
16206 static PyObject *_wrap_ART_ERROR_get(void) {
16207 PyObject *pyobj;
16208
16209 {
16210 #if wxUSE_UNICODE
16211 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16212 #else
16213 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16214 #endif
16215 }
16216 return pyobj;
16217 }
16218
16219
16220 static int _wrap_ART_QUESTION_set(PyObject *) {
16221 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16222 return 1;
16223 }
16224
16225
16226 static PyObject *_wrap_ART_QUESTION_get(void) {
16227 PyObject *pyobj;
16228
16229 {
16230 #if wxUSE_UNICODE
16231 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16232 #else
16233 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16234 #endif
16235 }
16236 return pyobj;
16237 }
16238
16239
16240 static int _wrap_ART_WARNING_set(PyObject *) {
16241 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16242 return 1;
16243 }
16244
16245
16246 static PyObject *_wrap_ART_WARNING_get(void) {
16247 PyObject *pyobj;
16248
16249 {
16250 #if wxUSE_UNICODE
16251 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16252 #else
16253 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16254 #endif
16255 }
16256 return pyobj;
16257 }
16258
16259
16260 static int _wrap_ART_INFORMATION_set(PyObject *) {
16261 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16262 return 1;
16263 }
16264
16265
16266 static PyObject *_wrap_ART_INFORMATION_get(void) {
16267 PyObject *pyobj;
16268
16269 {
16270 #if wxUSE_UNICODE
16271 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16272 #else
16273 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16274 #endif
16275 }
16276 return pyobj;
16277 }
16278
16279
16280 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16281 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16282 return 1;
16283 }
16284
16285
16286 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16287 PyObject *pyobj;
16288
16289 {
16290 #if wxUSE_UNICODE
16291 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16292 #else
16293 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16294 #endif
16295 }
16296 return pyobj;
16297 }
16298
16299
16300 static int _wrap_ART_COPY_set(PyObject *) {
16301 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16302 return 1;
16303 }
16304
16305
16306 static PyObject *_wrap_ART_COPY_get(void) {
16307 PyObject *pyobj;
16308
16309 {
16310 #if wxUSE_UNICODE
16311 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16312 #else
16313 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16314 #endif
16315 }
16316 return pyobj;
16317 }
16318
16319
16320 static int _wrap_ART_CUT_set(PyObject *) {
16321 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16322 return 1;
16323 }
16324
16325
16326 static PyObject *_wrap_ART_CUT_get(void) {
16327 PyObject *pyobj;
16328
16329 {
16330 #if wxUSE_UNICODE
16331 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16332 #else
16333 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16334 #endif
16335 }
16336 return pyobj;
16337 }
16338
16339
16340 static int _wrap_ART_PASTE_set(PyObject *) {
16341 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16342 return 1;
16343 }
16344
16345
16346 static PyObject *_wrap_ART_PASTE_get(void) {
16347 PyObject *pyobj;
16348
16349 {
16350 #if wxUSE_UNICODE
16351 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16352 #else
16353 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16354 #endif
16355 }
16356 return pyobj;
16357 }
16358
16359
16360 static int _wrap_ART_DELETE_set(PyObject *) {
16361 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16362 return 1;
16363 }
16364
16365
16366 static PyObject *_wrap_ART_DELETE_get(void) {
16367 PyObject *pyobj;
16368
16369 {
16370 #if wxUSE_UNICODE
16371 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16372 #else
16373 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16374 #endif
16375 }
16376 return pyobj;
16377 }
16378
16379
16380 static int _wrap_ART_UNDO_set(PyObject *) {
16381 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16382 return 1;
16383 }
16384
16385
16386 static PyObject *_wrap_ART_UNDO_get(void) {
16387 PyObject *pyobj;
16388
16389 {
16390 #if wxUSE_UNICODE
16391 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16392 #else
16393 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16394 #endif
16395 }
16396 return pyobj;
16397 }
16398
16399
16400 static int _wrap_ART_REDO_set(PyObject *) {
16401 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16402 return 1;
16403 }
16404
16405
16406 static PyObject *_wrap_ART_REDO_get(void) {
16407 PyObject *pyobj;
16408
16409 {
16410 #if wxUSE_UNICODE
16411 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16412 #else
16413 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16414 #endif
16415 }
16416 return pyobj;
16417 }
16418
16419
16420 static int _wrap_ART_QUIT_set(PyObject *) {
16421 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16422 return 1;
16423 }
16424
16425
16426 static PyObject *_wrap_ART_QUIT_get(void) {
16427 PyObject *pyobj;
16428
16429 {
16430 #if wxUSE_UNICODE
16431 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16432 #else
16433 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16434 #endif
16435 }
16436 return pyobj;
16437 }
16438
16439
16440 static int _wrap_ART_FIND_set(PyObject *) {
16441 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16442 return 1;
16443 }
16444
16445
16446 static PyObject *_wrap_ART_FIND_get(void) {
16447 PyObject *pyobj;
16448
16449 {
16450 #if wxUSE_UNICODE
16451 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16452 #else
16453 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16454 #endif
16455 }
16456 return pyobj;
16457 }
16458
16459
16460 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16461 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16462 return 1;
16463 }
16464
16465
16466 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16467 PyObject *pyobj;
16468
16469 {
16470 #if wxUSE_UNICODE
16471 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16472 #else
16473 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16474 #endif
16475 }
16476 return pyobj;
16477 }
16478
16479
16480 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16481 PyObject *resultobj;
16482 wxPyArtProvider *result;
16483 char *kwnames[] = {
16484 NULL
16485 };
16486
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16488 {
16489 if (!wxPyCheckForApp()) SWIG_fail;
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (wxPyArtProvider *)new wxPyArtProvider();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16506 PyObject *arg2 = (PyObject *) 0 ;
16507 PyObject *arg3 = (PyObject *) 0 ;
16508 PyObject * obj0 = 0 ;
16509 PyObject * obj1 = 0 ;
16510 PyObject * obj2 = 0 ;
16511 char *kwnames[] = {
16512 (char *) "self",(char *) "self",(char *) "_class", NULL
16513 };
16514
16515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16517 if (SWIG_arg_fail(1)) SWIG_fail;
16518 arg2 = obj1;
16519 arg3 = obj2;
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 (arg1)->_setCallbackInfo(arg2,arg3);
16523
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 Py_INCREF(Py_None); resultobj = Py_None;
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16537 PyObject * obj0 = 0 ;
16538 char *kwnames[] = {
16539 (char *) "provider", NULL
16540 };
16541
16542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16544 if (SWIG_arg_fail(1)) SWIG_fail;
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 wxPyArtProvider::PushProvider(arg1);
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 Py_INCREF(Py_None); resultobj = Py_None;
16553 return resultobj;
16554 fail:
16555 return NULL;
16556 }
16557
16558
16559 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj;
16561 bool result;
16562 char *kwnames[] = {
16563 NULL
16564 };
16565
16566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 result = (bool)wxPyArtProvider::PopProvider();
16570
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 {
16575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16576 }
16577 return resultobj;
16578 fail:
16579 return NULL;
16580 }
16581
16582
16583 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj;
16585 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 char *kwnames[] = {
16589 (char *) "provider", NULL
16590 };
16591
16592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16594 if (SWIG_arg_fail(1)) SWIG_fail;
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16598
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 {
16603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16604 }
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj;
16613 wxString *arg1 = 0 ;
16614 wxString const &arg2_defvalue = wxPyART_OTHER ;
16615 wxString *arg2 = (wxString *) &arg2_defvalue ;
16616 wxSize const &arg3_defvalue = wxDefaultSize ;
16617 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16618 wxBitmap result;
16619 bool temp1 = false ;
16620 bool temp2 = false ;
16621 wxSize temp3 ;
16622 PyObject * obj0 = 0 ;
16623 PyObject * obj1 = 0 ;
16624 PyObject * obj2 = 0 ;
16625 char *kwnames[] = {
16626 (char *) "id",(char *) "client",(char *) "size", NULL
16627 };
16628
16629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16630 {
16631 arg1 = wxString_in_helper(obj0);
16632 if (arg1 == NULL) SWIG_fail;
16633 temp1 = true;
16634 }
16635 if (obj1) {
16636 {
16637 arg2 = wxString_in_helper(obj1);
16638 if (arg2 == NULL) SWIG_fail;
16639 temp2 = true;
16640 }
16641 }
16642 if (obj2) {
16643 {
16644 arg3 = &temp3;
16645 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16646 }
16647 }
16648 {
16649 if (!wxPyCheckForApp()) SWIG_fail;
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 {
16657 wxBitmap * resultptr;
16658 resultptr = new wxBitmap((wxBitmap &)(result));
16659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16660 }
16661 {
16662 if (temp1)
16663 delete arg1;
16664 }
16665 {
16666 if (temp2)
16667 delete arg2;
16668 }
16669 return resultobj;
16670 fail:
16671 {
16672 if (temp1)
16673 delete arg1;
16674 }
16675 {
16676 if (temp2)
16677 delete arg2;
16678 }
16679 return NULL;
16680 }
16681
16682
16683 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj;
16685 wxString *arg1 = 0 ;
16686 wxString const &arg2_defvalue = wxPyART_OTHER ;
16687 wxString *arg2 = (wxString *) &arg2_defvalue ;
16688 wxSize const &arg3_defvalue = wxDefaultSize ;
16689 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16690 wxIcon result;
16691 bool temp1 = false ;
16692 bool temp2 = false ;
16693 wxSize temp3 ;
16694 PyObject * obj0 = 0 ;
16695 PyObject * obj1 = 0 ;
16696 PyObject * obj2 = 0 ;
16697 char *kwnames[] = {
16698 (char *) "id",(char *) "client",(char *) "size", NULL
16699 };
16700
16701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16702 {
16703 arg1 = wxString_in_helper(obj0);
16704 if (arg1 == NULL) SWIG_fail;
16705 temp1 = true;
16706 }
16707 if (obj1) {
16708 {
16709 arg2 = wxString_in_helper(obj1);
16710 if (arg2 == NULL) SWIG_fail;
16711 temp2 = true;
16712 }
16713 }
16714 if (obj2) {
16715 {
16716 arg3 = &temp3;
16717 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16718 }
16719 }
16720 {
16721 if (!wxPyCheckForApp()) SWIG_fail;
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 {
16729 wxIcon * resultptr;
16730 resultptr = new wxIcon((wxIcon &)(result));
16731 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16732 }
16733 {
16734 if (temp1)
16735 delete arg1;
16736 }
16737 {
16738 if (temp2)
16739 delete arg2;
16740 }
16741 return resultobj;
16742 fail:
16743 {
16744 if (temp1)
16745 delete arg1;
16746 }
16747 {
16748 if (temp2)
16749 delete arg2;
16750 }
16751 return NULL;
16752 }
16753
16754
16755 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj;
16757 wxString *arg1 = 0 ;
16758 bool arg2 = (bool) false ;
16759 wxSize result;
16760 bool temp1 = false ;
16761 PyObject * obj0 = 0 ;
16762 PyObject * obj1 = 0 ;
16763 char *kwnames[] = {
16764 (char *) "client",(char *) "platform_dependent", NULL
16765 };
16766
16767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16768 {
16769 arg1 = wxString_in_helper(obj0);
16770 if (arg1 == NULL) SWIG_fail;
16771 temp1 = true;
16772 }
16773 if (obj1) {
16774 {
16775 arg2 = (bool)(SWIG_As_bool(obj1));
16776 if (SWIG_arg_fail(2)) SWIG_fail;
16777 }
16778 }
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16782
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 {
16787 wxSize * resultptr;
16788 resultptr = new wxSize((wxSize &)(result));
16789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16790 }
16791 {
16792 if (temp1)
16793 delete arg1;
16794 }
16795 return resultobj;
16796 fail:
16797 {
16798 if (temp1)
16799 delete arg1;
16800 }
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16808 PyObject * obj0 = 0 ;
16809 char *kwnames[] = {
16810 (char *) "self", NULL
16811 };
16812
16813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16815 if (SWIG_arg_fail(1)) SWIG_fail;
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 wxPyArtProvider_Destroy(arg1);
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 Py_INCREF(Py_None); resultobj = Py_None;
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16831 PyObject *obj;
16832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16833 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16834 Py_INCREF(obj);
16835 return Py_BuildValue((char *)"");
16836 }
16837 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj;
16839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 delete arg1;
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16865 wxConfigBase *result;
16866 PyObject * obj0 = 0 ;
16867 char *kwnames[] = {
16868 (char *) "config", NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16873 if (SWIG_arg_fail(1)) SWIG_fail;
16874 {
16875 PyThreadState* __tstate = wxPyBeginAllowThreads();
16876 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16877
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16882 return resultobj;
16883 fail:
16884 return NULL;
16885 }
16886
16887
16888 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16889 PyObject *resultobj;
16890 bool arg1 = (bool) true ;
16891 wxConfigBase *result;
16892 PyObject * obj0 = 0 ;
16893 char *kwnames[] = {
16894 (char *) "createOnDemand", NULL
16895 };
16896
16897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16898 if (obj0) {
16899 {
16900 arg1 = (bool)(SWIG_As_bool(obj0));
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 }
16903 }
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16919 PyObject *resultobj;
16920 wxConfigBase *result;
16921 char *kwnames[] = {
16922 NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = (wxConfigBase *)wxConfigBase::Create();
16929
16930 wxPyEndAllowThreads(__tstate);
16931 if (PyErr_Occurred()) SWIG_fail;
16932 }
16933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16934 return resultobj;
16935 fail:
16936 return NULL;
16937 }
16938
16939
16940 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16941 PyObject *resultobj;
16942 char *kwnames[] = {
16943 NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16947 {
16948 PyThreadState* __tstate = wxPyBeginAllowThreads();
16949 wxConfigBase::DontCreateOnDemand();
16950
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 Py_INCREF(Py_None); resultobj = Py_None;
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16962 PyObject *resultobj;
16963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16964 wxString *arg2 = 0 ;
16965 bool temp2 = false ;
16966 PyObject * obj0 = 0 ;
16967 PyObject * obj1 = 0 ;
16968 char *kwnames[] = {
16969 (char *) "self",(char *) "path", NULL
16970 };
16971
16972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16974 if (SWIG_arg_fail(1)) SWIG_fail;
16975 {
16976 arg2 = wxString_in_helper(obj1);
16977 if (arg2 == NULL) SWIG_fail;
16978 temp2 = true;
16979 }
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 (arg1)->SetPath((wxString const &)*arg2);
16983
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 Py_INCREF(Py_None); resultobj = Py_None;
16988 {
16989 if (temp2)
16990 delete arg2;
16991 }
16992 return resultobj;
16993 fail:
16994 {
16995 if (temp2)
16996 delete arg2;
16997 }
16998 return NULL;
16999 }
17000
17001
17002 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj;
17004 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17005 wxString *result;
17006 PyObject * obj0 = 0 ;
17007 char *kwnames[] = {
17008 (char *) "self", NULL
17009 };
17010
17011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17013 if (SWIG_arg_fail(1)) SWIG_fail;
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 {
17017 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17018 result = (wxString *) &_result_ref;
17019 }
17020
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 {
17025 #if wxUSE_UNICODE
17026 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17027 #else
17028 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17029 #endif
17030 }
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj;
17039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17040 PyObject *result;
17041 PyObject * obj0 = 0 ;
17042 char *kwnames[] = {
17043 (char *) "self", NULL
17044 };
17045
17046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17048 if (SWIG_arg_fail(1)) SWIG_fail;
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 resultobj = result;
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17066 long arg2 ;
17067 PyObject *result;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 char *kwnames[] = {
17071 (char *) "self",(char *) "index", NULL
17072 };
17073
17074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17076 if (SWIG_arg_fail(1)) SWIG_fail;
17077 {
17078 arg2 = (long)(SWIG_As_long(obj1));
17079 if (SWIG_arg_fail(2)) SWIG_fail;
17080 }
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17084
17085 wxPyEndAllowThreads(__tstate);
17086 if (PyErr_Occurred()) SWIG_fail;
17087 }
17088 resultobj = result;
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj;
17097 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17098 PyObject *result;
17099 PyObject * obj0 = 0 ;
17100 char *kwnames[] = {
17101 (char *) "self", NULL
17102 };
17103
17104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17106 if (SWIG_arg_fail(1)) SWIG_fail;
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17110
17111 wxPyEndAllowThreads(__tstate);
17112 if (PyErr_Occurred()) SWIG_fail;
17113 }
17114 resultobj = result;
17115 return resultobj;
17116 fail:
17117 return NULL;
17118 }
17119
17120
17121 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17122 PyObject *resultobj;
17123 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17124 long arg2 ;
17125 PyObject *result;
17126 PyObject * obj0 = 0 ;
17127 PyObject * obj1 = 0 ;
17128 char *kwnames[] = {
17129 (char *) "self",(char *) "index", NULL
17130 };
17131
17132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17134 if (SWIG_arg_fail(1)) SWIG_fail;
17135 {
17136 arg2 = (long)(SWIG_As_long(obj1));
17137 if (SWIG_arg_fail(2)) SWIG_fail;
17138 }
17139 {
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17142
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 resultobj = result;
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17156 bool arg2 = (bool) false ;
17157 size_t result;
17158 PyObject * obj0 = 0 ;
17159 PyObject * obj1 = 0 ;
17160 char *kwnames[] = {
17161 (char *) "self",(char *) "recursive", NULL
17162 };
17163
17164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17166 if (SWIG_arg_fail(1)) SWIG_fail;
17167 if (obj1) {
17168 {
17169 arg2 = (bool)(SWIG_As_bool(obj1));
17170 if (SWIG_arg_fail(2)) SWIG_fail;
17171 }
17172 }
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17176
17177 wxPyEndAllowThreads(__tstate);
17178 if (PyErr_Occurred()) SWIG_fail;
17179 }
17180 {
17181 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17182 }
17183 return resultobj;
17184 fail:
17185 return NULL;
17186 }
17187
17188
17189 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj;
17191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17192 bool arg2 = (bool) false ;
17193 size_t result;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self",(char *) "recursive", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 if (obj1) {
17204 {
17205 arg2 = (bool)(SWIG_As_bool(obj1));
17206 if (SWIG_arg_fail(2)) SWIG_fail;
17207 }
17208 }
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17218 }
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj;
17227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17228 wxString *arg2 = 0 ;
17229 bool result;
17230 bool temp2 = false ;
17231 PyObject * obj0 = 0 ;
17232 PyObject * obj1 = 0 ;
17233 char *kwnames[] = {
17234 (char *) "self",(char *) "name", NULL
17235 };
17236
17237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(1)) SWIG_fail;
17240 {
17241 arg2 = wxString_in_helper(obj1);
17242 if (arg2 == NULL) SWIG_fail;
17243 temp2 = true;
17244 }
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17248
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 {
17256 if (temp2)
17257 delete arg2;
17258 }
17259 return resultobj;
17260 fail:
17261 {
17262 if (temp2)
17263 delete arg2;
17264 }
17265 return NULL;
17266 }
17267
17268
17269 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17270 PyObject *resultobj;
17271 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17272 wxString *arg2 = 0 ;
17273 bool result;
17274 bool temp2 = false ;
17275 PyObject * obj0 = 0 ;
17276 PyObject * obj1 = 0 ;
17277 char *kwnames[] = {
17278 (char *) "self",(char *) "name", NULL
17279 };
17280
17281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(1)) SWIG_fail;
17284 {
17285 arg2 = wxString_in_helper(obj1);
17286 if (arg2 == NULL) SWIG_fail;
17287 temp2 = true;
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17292
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 {
17297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17298 }
17299 {
17300 if (temp2)
17301 delete arg2;
17302 }
17303 return resultobj;
17304 fail:
17305 {
17306 if (temp2)
17307 delete arg2;
17308 }
17309 return NULL;
17310 }
17311
17312
17313 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17314 PyObject *resultobj;
17315 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17316 wxString *arg2 = 0 ;
17317 bool result;
17318 bool temp2 = false ;
17319 PyObject * obj0 = 0 ;
17320 PyObject * obj1 = 0 ;
17321 char *kwnames[] = {
17322 (char *) "self",(char *) "name", NULL
17323 };
17324
17325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17327 if (SWIG_arg_fail(1)) SWIG_fail;
17328 {
17329 arg2 = wxString_in_helper(obj1);
17330 if (arg2 == NULL) SWIG_fail;
17331 temp2 = true;
17332 }
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 {
17341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17342 }
17343 {
17344 if (temp2)
17345 delete arg2;
17346 }
17347 return resultobj;
17348 fail:
17349 {
17350 if (temp2)
17351 delete arg2;
17352 }
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj;
17359 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17360 wxString *arg2 = 0 ;
17361 wxConfigBase::EntryType result;
17362 bool temp2 = false ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self",(char *) "name", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 arg2 = wxString_in_helper(obj1);
17374 if (arg2 == NULL) SWIG_fail;
17375 temp2 = true;
17376 }
17377 {
17378 PyThreadState* __tstate = wxPyBeginAllowThreads();
17379 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17380
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 resultobj = SWIG_From_int((result));
17385 {
17386 if (temp2)
17387 delete arg2;
17388 }
17389 return resultobj;
17390 fail:
17391 {
17392 if (temp2)
17393 delete arg2;
17394 }
17395 return NULL;
17396 }
17397
17398
17399 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj;
17401 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17402 wxString *arg2 = 0 ;
17403 wxString const &arg3_defvalue = wxPyEmptyString ;
17404 wxString *arg3 = (wxString *) &arg3_defvalue ;
17405 wxString result;
17406 bool temp2 = false ;
17407 bool temp3 = false ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 {
17419 arg2 = wxString_in_helper(obj1);
17420 if (arg2 == NULL) SWIG_fail;
17421 temp2 = true;
17422 }
17423 if (obj2) {
17424 {
17425 arg3 = wxString_in_helper(obj2);
17426 if (arg3 == NULL) SWIG_fail;
17427 temp3 = true;
17428 }
17429 }
17430 {
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17433
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 {
17438 #if wxUSE_UNICODE
17439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17440 #else
17441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17442 #endif
17443 }
17444 {
17445 if (temp2)
17446 delete arg2;
17447 }
17448 {
17449 if (temp3)
17450 delete arg3;
17451 }
17452 return resultobj;
17453 fail:
17454 {
17455 if (temp2)
17456 delete arg2;
17457 }
17458 {
17459 if (temp3)
17460 delete arg3;
17461 }
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17469 wxString *arg2 = 0 ;
17470 long arg3 = (long) 0 ;
17471 long result;
17472 bool temp2 = false ;
17473 PyObject * obj0 = 0 ;
17474 PyObject * obj1 = 0 ;
17475 PyObject * obj2 = 0 ;
17476 char *kwnames[] = {
17477 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17482 if (SWIG_arg_fail(1)) SWIG_fail;
17483 {
17484 arg2 = wxString_in_helper(obj1);
17485 if (arg2 == NULL) SWIG_fail;
17486 temp2 = true;
17487 }
17488 if (obj2) {
17489 {
17490 arg3 = (long)(SWIG_As_long(obj2));
17491 if (SWIG_arg_fail(3)) SWIG_fail;
17492 }
17493 }
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17497
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 {
17502 resultobj = SWIG_From_long((long)(result));
17503 }
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 return resultobj;
17509 fail:
17510 {
17511 if (temp2)
17512 delete arg2;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj;
17520 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17521 wxString *arg2 = 0 ;
17522 double arg3 = (double) 0.0 ;
17523 double result;
17524 bool temp2 = false ;
17525 PyObject * obj0 = 0 ;
17526 PyObject * obj1 = 0 ;
17527 PyObject * obj2 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 arg2 = wxString_in_helper(obj1);
17537 if (arg2 == NULL) SWIG_fail;
17538 temp2 = true;
17539 }
17540 if (obj2) {
17541 {
17542 arg3 = (double)(SWIG_As_double(obj2));
17543 if (SWIG_arg_fail(3)) SWIG_fail;
17544 }
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 resultobj = SWIG_From_double((double)(result));
17555 }
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return resultobj;
17561 fail:
17562 {
17563 if (temp2)
17564 delete arg2;
17565 }
17566 return NULL;
17567 }
17568
17569
17570 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj;
17572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17573 wxString *arg2 = 0 ;
17574 bool arg3 = (bool) false ;
17575 bool result;
17576 bool temp2 = false ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 PyObject * obj2 = 0 ;
17580 char *kwnames[] = {
17581 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17582 };
17583
17584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17586 if (SWIG_arg_fail(1)) SWIG_fail;
17587 {
17588 arg2 = wxString_in_helper(obj1);
17589 if (arg2 == NULL) SWIG_fail;
17590 temp2 = true;
17591 }
17592 if (obj2) {
17593 {
17594 arg3 = (bool)(SWIG_As_bool(obj2));
17595 if (SWIG_arg_fail(3)) SWIG_fail;
17596 }
17597 }
17598 {
17599 PyThreadState* __tstate = wxPyBeginAllowThreads();
17600 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17601
17602 wxPyEndAllowThreads(__tstate);
17603 if (PyErr_Occurred()) SWIG_fail;
17604 }
17605 {
17606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17607 }
17608 {
17609 if (temp2)
17610 delete arg2;
17611 }
17612 return resultobj;
17613 fail:
17614 {
17615 if (temp2)
17616 delete arg2;
17617 }
17618 return NULL;
17619 }
17620
17621
17622 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17625 wxString *arg2 = 0 ;
17626 wxString *arg3 = 0 ;
17627 bool result;
17628 bool temp2 = false ;
17629 bool temp3 = false ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 PyObject * obj2 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self",(char *) "key",(char *) "value", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 arg2 = wxString_in_helper(obj1);
17642 if (arg2 == NULL) SWIG_fail;
17643 temp2 = true;
17644 }
17645 {
17646 arg3 = wxString_in_helper(obj2);
17647 if (arg3 == NULL) SWIG_fail;
17648 temp3 = true;
17649 }
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17653
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 {
17661 if (temp2)
17662 delete arg2;
17663 }
17664 {
17665 if (temp3)
17666 delete arg3;
17667 }
17668 return resultobj;
17669 fail:
17670 {
17671 if (temp2)
17672 delete arg2;
17673 }
17674 {
17675 if (temp3)
17676 delete arg3;
17677 }
17678 return NULL;
17679 }
17680
17681
17682 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17683 PyObject *resultobj;
17684 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17685 wxString *arg2 = 0 ;
17686 long arg3 ;
17687 bool result;
17688 bool temp2 = false ;
17689 PyObject * obj0 = 0 ;
17690 PyObject * obj1 = 0 ;
17691 PyObject * obj2 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self",(char *) "key",(char *) "value", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 arg2 = wxString_in_helper(obj1);
17701 if (arg2 == NULL) SWIG_fail;
17702 temp2 = true;
17703 }
17704 {
17705 arg3 = (long)(SWIG_As_long(obj2));
17706 if (SWIG_arg_fail(3)) SWIG_fail;
17707 }
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17711
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 {
17716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17717 }
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return resultobj;
17723 fail:
17724 {
17725 if (temp2)
17726 delete arg2;
17727 }
17728 return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj;
17734 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17735 wxString *arg2 = 0 ;
17736 double arg3 ;
17737 bool result;
17738 bool temp2 = false ;
17739 PyObject * obj0 = 0 ;
17740 PyObject * obj1 = 0 ;
17741 PyObject * obj2 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self",(char *) "key",(char *) "value", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 {
17750 arg2 = wxString_in_helper(obj1);
17751 if (arg2 == NULL) SWIG_fail;
17752 temp2 = true;
17753 }
17754 {
17755 arg3 = (double)(SWIG_As_double(obj2));
17756 if (SWIG_arg_fail(3)) SWIG_fail;
17757 }
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 {
17766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17767 }
17768 {
17769 if (temp2)
17770 delete arg2;
17771 }
17772 return resultobj;
17773 fail:
17774 {
17775 if (temp2)
17776 delete arg2;
17777 }
17778 return NULL;
17779 }
17780
17781
17782 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17783 PyObject *resultobj;
17784 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17785 wxString *arg2 = 0 ;
17786 bool arg3 ;
17787 bool result;
17788 bool temp2 = false ;
17789 PyObject * obj0 = 0 ;
17790 PyObject * obj1 = 0 ;
17791 PyObject * obj2 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self",(char *) "key",(char *) "value", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 arg2 = wxString_in_helper(obj1);
17801 if (arg2 == NULL) SWIG_fail;
17802 temp2 = true;
17803 }
17804 {
17805 arg3 = (bool)(SWIG_As_bool(obj2));
17806 if (SWIG_arg_fail(3)) SWIG_fail;
17807 }
17808 {
17809 PyThreadState* __tstate = wxPyBeginAllowThreads();
17810 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17811
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 {
17819 if (temp2)
17820 delete arg2;
17821 }
17822 return resultobj;
17823 fail:
17824 {
17825 if (temp2)
17826 delete arg2;
17827 }
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17835 bool arg2 = (bool) false ;
17836 bool result;
17837 PyObject * obj0 = 0 ;
17838 PyObject * obj1 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self",(char *) "currentOnly", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 if (obj1) {
17847 {
17848 arg2 = (bool)(SWIG_As_bool(obj1));
17849 if (SWIG_arg_fail(2)) SWIG_fail;
17850 }
17851 }
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 result = (bool)(arg1)->Flush(arg2);
17855
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 {
17860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17861 }
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17869 PyObject *resultobj;
17870 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17871 wxString *arg2 = 0 ;
17872 wxString *arg3 = 0 ;
17873 bool result;
17874 bool temp2 = false ;
17875 bool temp3 = false ;
17876 PyObject * obj0 = 0 ;
17877 PyObject * obj1 = 0 ;
17878 PyObject * obj2 = 0 ;
17879 char *kwnames[] = {
17880 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17881 };
17882
17883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17885 if (SWIG_arg_fail(1)) SWIG_fail;
17886 {
17887 arg2 = wxString_in_helper(obj1);
17888 if (arg2 == NULL) SWIG_fail;
17889 temp2 = true;
17890 }
17891 {
17892 arg3 = wxString_in_helper(obj2);
17893 if (arg3 == NULL) SWIG_fail;
17894 temp3 = true;
17895 }
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17899
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 {
17904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17905 }
17906 {
17907 if (temp2)
17908 delete arg2;
17909 }
17910 {
17911 if (temp3)
17912 delete arg3;
17913 }
17914 return resultobj;
17915 fail:
17916 {
17917 if (temp2)
17918 delete arg2;
17919 }
17920 {
17921 if (temp3)
17922 delete arg3;
17923 }
17924 return NULL;
17925 }
17926
17927
17928 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17929 PyObject *resultobj;
17930 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17931 wxString *arg2 = 0 ;
17932 wxString *arg3 = 0 ;
17933 bool result;
17934 bool temp2 = false ;
17935 bool temp3 = false ;
17936 PyObject * obj0 = 0 ;
17937 PyObject * obj1 = 0 ;
17938 PyObject * obj2 = 0 ;
17939 char *kwnames[] = {
17940 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17941 };
17942
17943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17945 if (SWIG_arg_fail(1)) SWIG_fail;
17946 {
17947 arg2 = wxString_in_helper(obj1);
17948 if (arg2 == NULL) SWIG_fail;
17949 temp2 = true;
17950 }
17951 {
17952 arg3 = wxString_in_helper(obj2);
17953 if (arg3 == NULL) SWIG_fail;
17954 temp3 = true;
17955 }
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17965 }
17966 {
17967 if (temp2)
17968 delete arg2;
17969 }
17970 {
17971 if (temp3)
17972 delete arg3;
17973 }
17974 return resultobj;
17975 fail:
17976 {
17977 if (temp2)
17978 delete arg2;
17979 }
17980 {
17981 if (temp3)
17982 delete arg3;
17983 }
17984 return NULL;
17985 }
17986
17987
17988 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17989 PyObject *resultobj;
17990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17991 wxString *arg2 = 0 ;
17992 bool arg3 = (bool) true ;
17993 bool result;
17994 bool temp2 = false ;
17995 PyObject * obj0 = 0 ;
17996 PyObject * obj1 = 0 ;
17997 PyObject * obj2 = 0 ;
17998 char *kwnames[] = {
17999 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18000 };
18001
18002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18004 if (SWIG_arg_fail(1)) SWIG_fail;
18005 {
18006 arg2 = wxString_in_helper(obj1);
18007 if (arg2 == NULL) SWIG_fail;
18008 temp2 = true;
18009 }
18010 if (obj2) {
18011 {
18012 arg3 = (bool)(SWIG_As_bool(obj2));
18013 if (SWIG_arg_fail(3)) SWIG_fail;
18014 }
18015 }
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18025 }
18026 {
18027 if (temp2)
18028 delete arg2;
18029 }
18030 return resultobj;
18031 fail:
18032 {
18033 if (temp2)
18034 delete arg2;
18035 }
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18043 wxString *arg2 = 0 ;
18044 bool result;
18045 bool temp2 = false ;
18046 PyObject * obj0 = 0 ;
18047 PyObject * obj1 = 0 ;
18048 char *kwnames[] = {
18049 (char *) "self",(char *) "key", NULL
18050 };
18051
18052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18054 if (SWIG_arg_fail(1)) SWIG_fail;
18055 {
18056 arg2 = wxString_in_helper(obj1);
18057 if (arg2 == NULL) SWIG_fail;
18058 temp2 = true;
18059 }
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18063
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 {
18068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18069 }
18070 {
18071 if (temp2)
18072 delete arg2;
18073 }
18074 return resultobj;
18075 fail:
18076 {
18077 if (temp2)
18078 delete arg2;
18079 }
18080 return NULL;
18081 }
18082
18083
18084 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18085 PyObject *resultobj;
18086 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18087 bool result;
18088 PyObject * obj0 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "self", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18095 if (SWIG_arg_fail(1)) SWIG_fail;
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (bool)(arg1)->DeleteAll();
18099
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 {
18104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18105 }
18106 return resultobj;
18107 fail:
18108 return NULL;
18109 }
18110
18111
18112 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18113 PyObject *resultobj;
18114 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18115 bool arg2 = (bool) true ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 char *kwnames[] = {
18119 (char *) "self",(char *) "doIt", NULL
18120 };
18121
18122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18124 if (SWIG_arg_fail(1)) SWIG_fail;
18125 if (obj1) {
18126 {
18127 arg2 = (bool)(SWIG_As_bool(obj1));
18128 if (SWIG_arg_fail(2)) SWIG_fail;
18129 }
18130 }
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 (arg1)->SetExpandEnvVars(arg2);
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 Py_INCREF(Py_None); resultobj = Py_None;
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18148 bool result;
18149 PyObject * obj0 = 0 ;
18150 char *kwnames[] = {
18151 (char *) "self", NULL
18152 };
18153
18154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18156 if (SWIG_arg_fail(1)) SWIG_fail;
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18160
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 {
18165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18166 }
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18174 PyObject *resultobj;
18175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18176 bool arg2 = (bool) true ;
18177 PyObject * obj0 = 0 ;
18178 PyObject * obj1 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self",(char *) "doIt", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 if (obj1) {
18187 {
18188 arg2 = (bool)(SWIG_As_bool(obj1));
18189 if (SWIG_arg_fail(2)) SWIG_fail;
18190 }
18191 }
18192 {
18193 PyThreadState* __tstate = wxPyBeginAllowThreads();
18194 (arg1)->SetRecordDefaults(arg2);
18195
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 Py_INCREF(Py_None); resultobj = Py_None;
18200 return resultobj;
18201 fail:
18202 return NULL;
18203 }
18204
18205
18206 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18207 PyObject *resultobj;
18208 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18209 bool result;
18210 PyObject * obj0 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(1)) SWIG_fail;
18218 {
18219 PyThreadState* __tstate = wxPyBeginAllowThreads();
18220 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18221
18222 wxPyEndAllowThreads(__tstate);
18223 if (PyErr_Occurred()) SWIG_fail;
18224 }
18225 {
18226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18227 }
18228 return resultobj;
18229 fail:
18230 return NULL;
18231 }
18232
18233
18234 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18235 PyObject *resultobj;
18236 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18237 wxString *arg2 = 0 ;
18238 wxString result;
18239 bool temp2 = false ;
18240 PyObject * obj0 = 0 ;
18241 PyObject * obj1 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self",(char *) "str", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 {
18250 arg2 = wxString_in_helper(obj1);
18251 if (arg2 == NULL) SWIG_fail;
18252 temp2 = true;
18253 }
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18257
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 {
18262 #if wxUSE_UNICODE
18263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18264 #else
18265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18266 #endif
18267 }
18268 {
18269 if (temp2)
18270 delete arg2;
18271 }
18272 return resultobj;
18273 fail:
18274 {
18275 if (temp2)
18276 delete arg2;
18277 }
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18285 wxString result;
18286 PyObject * obj0 = 0 ;
18287 char *kwnames[] = {
18288 (char *) "self", NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18293 if (SWIG_arg_fail(1)) SWIG_fail;
18294 {
18295 PyThreadState* __tstate = wxPyBeginAllowThreads();
18296 result = ((wxConfigBase const *)arg1)->GetAppName();
18297
18298 wxPyEndAllowThreads(__tstate);
18299 if (PyErr_Occurred()) SWIG_fail;
18300 }
18301 {
18302 #if wxUSE_UNICODE
18303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18304 #else
18305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18306 #endif
18307 }
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18317 wxString result;
18318 PyObject * obj0 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = ((wxConfigBase const *)arg1)->GetVendorName();
18329
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 #if wxUSE_UNICODE
18335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18336 #else
18337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18338 #endif
18339 }
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj;
18348 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18349 wxString *arg2 = 0 ;
18350 bool temp2 = false ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char *kwnames[] = {
18354 (char *) "self",(char *) "appName", NULL
18355 };
18356
18357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18359 if (SWIG_arg_fail(1)) SWIG_fail;
18360 {
18361 arg2 = wxString_in_helper(obj1);
18362 if (arg2 == NULL) SWIG_fail;
18363 temp2 = true;
18364 }
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 (arg1)->SetAppName((wxString const &)*arg2);
18368
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 Py_INCREF(Py_None); resultobj = Py_None;
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 return resultobj;
18378 fail:
18379 {
18380 if (temp2)
18381 delete arg2;
18382 }
18383 return NULL;
18384 }
18385
18386
18387 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj;
18389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18390 wxString *arg2 = 0 ;
18391 bool temp2 = false ;
18392 PyObject * obj0 = 0 ;
18393 PyObject * obj1 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self",(char *) "vendorName", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 {
18402 arg2 = wxString_in_helper(obj1);
18403 if (arg2 == NULL) SWIG_fail;
18404 temp2 = true;
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 (arg1)->SetVendorName((wxString const &)*arg2);
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 Py_INCREF(Py_None); resultobj = Py_None;
18414 {
18415 if (temp2)
18416 delete arg2;
18417 }
18418 return resultobj;
18419 fail:
18420 {
18421 if (temp2)
18422 delete arg2;
18423 }
18424 return NULL;
18425 }
18426
18427
18428 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18429 PyObject *resultobj;
18430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18431 long arg2 ;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self",(char *) "style", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 arg2 = (long)(SWIG_As_long(obj1));
18443 if (SWIG_arg_fail(2)) SWIG_fail;
18444 }
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 (arg1)->SetStyle(arg2);
18448
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 Py_INCREF(Py_None); resultobj = Py_None;
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj;
18461 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18462 long result;
18463 PyObject * obj0 = 0 ;
18464 char *kwnames[] = {
18465 (char *) "self", NULL
18466 };
18467
18468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18470 if (SWIG_arg_fail(1)) SWIG_fail;
18471 {
18472 PyThreadState* __tstate = wxPyBeginAllowThreads();
18473 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18474
18475 wxPyEndAllowThreads(__tstate);
18476 if (PyErr_Occurred()) SWIG_fail;
18477 }
18478 {
18479 resultobj = SWIG_From_long((long)(result));
18480 }
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18488 PyObject *obj;
18489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18490 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18491 Py_INCREF(obj);
18492 return Py_BuildValue((char *)"");
18493 }
18494 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxString const &arg1_defvalue = wxPyEmptyString ;
18497 wxString *arg1 = (wxString *) &arg1_defvalue ;
18498 wxString const &arg2_defvalue = wxPyEmptyString ;
18499 wxString *arg2 = (wxString *) &arg2_defvalue ;
18500 wxString const &arg3_defvalue = wxPyEmptyString ;
18501 wxString *arg3 = (wxString *) &arg3_defvalue ;
18502 wxString const &arg4_defvalue = wxPyEmptyString ;
18503 wxString *arg4 = (wxString *) &arg4_defvalue ;
18504 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18505 wxConfig *result;
18506 bool temp1 = false ;
18507 bool temp2 = false ;
18508 bool temp3 = false ;
18509 bool temp4 = false ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 PyObject * obj2 = 0 ;
18513 PyObject * obj3 = 0 ;
18514 PyObject * obj4 = 0 ;
18515 char *kwnames[] = {
18516 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18517 };
18518
18519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18520 if (obj0) {
18521 {
18522 arg1 = wxString_in_helper(obj0);
18523 if (arg1 == NULL) SWIG_fail;
18524 temp1 = true;
18525 }
18526 }
18527 if (obj1) {
18528 {
18529 arg2 = wxString_in_helper(obj1);
18530 if (arg2 == NULL) SWIG_fail;
18531 temp2 = true;
18532 }
18533 }
18534 if (obj2) {
18535 {
18536 arg3 = wxString_in_helper(obj2);
18537 if (arg3 == NULL) SWIG_fail;
18538 temp3 = true;
18539 }
18540 }
18541 if (obj3) {
18542 {
18543 arg4 = wxString_in_helper(obj3);
18544 if (arg4 == NULL) SWIG_fail;
18545 temp4 = true;
18546 }
18547 }
18548 if (obj4) {
18549 {
18550 arg5 = (long)(SWIG_As_long(obj4));
18551 if (SWIG_arg_fail(5)) SWIG_fail;
18552 }
18553 }
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18557
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18562 {
18563 if (temp1)
18564 delete arg1;
18565 }
18566 {
18567 if (temp2)
18568 delete arg2;
18569 }
18570 {
18571 if (temp3)
18572 delete arg3;
18573 }
18574 {
18575 if (temp4)
18576 delete arg4;
18577 }
18578 return resultobj;
18579 fail:
18580 {
18581 if (temp1)
18582 delete arg1;
18583 }
18584 {
18585 if (temp2)
18586 delete arg2;
18587 }
18588 {
18589 if (temp3)
18590 delete arg3;
18591 }
18592 {
18593 if (temp4)
18594 delete arg4;
18595 }
18596 return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj;
18602 wxConfig *arg1 = (wxConfig *) 0 ;
18603 PyObject * obj0 = 0 ;
18604 char *kwnames[] = {
18605 (char *) "self", NULL
18606 };
18607
18608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18610 if (SWIG_arg_fail(1)) SWIG_fail;
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 delete arg1;
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 Py_INCREF(Py_None); resultobj = Py_None;
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18626 PyObject *obj;
18627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18628 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18629 Py_INCREF(obj);
18630 return Py_BuildValue((char *)"");
18631 }
18632 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxString const &arg1_defvalue = wxPyEmptyString ;
18635 wxString *arg1 = (wxString *) &arg1_defvalue ;
18636 wxString const &arg2_defvalue = wxPyEmptyString ;
18637 wxString *arg2 = (wxString *) &arg2_defvalue ;
18638 wxString const &arg3_defvalue = wxPyEmptyString ;
18639 wxString *arg3 = (wxString *) &arg3_defvalue ;
18640 wxString const &arg4_defvalue = wxPyEmptyString ;
18641 wxString *arg4 = (wxString *) &arg4_defvalue ;
18642 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18643 wxFileConfig *result;
18644 bool temp1 = false ;
18645 bool temp2 = false ;
18646 bool temp3 = false ;
18647 bool temp4 = false ;
18648 PyObject * obj0 = 0 ;
18649 PyObject * obj1 = 0 ;
18650 PyObject * obj2 = 0 ;
18651 PyObject * obj3 = 0 ;
18652 PyObject * obj4 = 0 ;
18653 char *kwnames[] = {
18654 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18655 };
18656
18657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18658 if (obj0) {
18659 {
18660 arg1 = wxString_in_helper(obj0);
18661 if (arg1 == NULL) SWIG_fail;
18662 temp1 = true;
18663 }
18664 }
18665 if (obj1) {
18666 {
18667 arg2 = wxString_in_helper(obj1);
18668 if (arg2 == NULL) SWIG_fail;
18669 temp2 = true;
18670 }
18671 }
18672 if (obj2) {
18673 {
18674 arg3 = wxString_in_helper(obj2);
18675 if (arg3 == NULL) SWIG_fail;
18676 temp3 = true;
18677 }
18678 }
18679 if (obj3) {
18680 {
18681 arg4 = wxString_in_helper(obj3);
18682 if (arg4 == NULL) SWIG_fail;
18683 temp4 = true;
18684 }
18685 }
18686 if (obj4) {
18687 {
18688 arg5 = (long)(SWIG_As_long(obj4));
18689 if (SWIG_arg_fail(5)) SWIG_fail;
18690 }
18691 }
18692 {
18693 PyThreadState* __tstate = wxPyBeginAllowThreads();
18694 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18695
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18700 {
18701 if (temp1)
18702 delete arg1;
18703 }
18704 {
18705 if (temp2)
18706 delete arg2;
18707 }
18708 {
18709 if (temp3)
18710 delete arg3;
18711 }
18712 {
18713 if (temp4)
18714 delete arg4;
18715 }
18716 return resultobj;
18717 fail:
18718 {
18719 if (temp1)
18720 delete arg1;
18721 }
18722 {
18723 if (temp2)
18724 delete arg2;
18725 }
18726 {
18727 if (temp3)
18728 delete arg3;
18729 }
18730 {
18731 if (temp4)
18732 delete arg4;
18733 }
18734 return NULL;
18735 }
18736
18737
18738 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18739 PyObject *resultobj;
18740 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18741 PyObject * obj0 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 delete arg1;
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 Py_INCREF(Py_None); resultobj = Py_None;
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18764 PyObject *obj;
18765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18766 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18767 Py_INCREF(obj);
18768 return Py_BuildValue((char *)"");
18769 }
18770 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj;
18772 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18773 wxString *arg2 = 0 ;
18774 wxConfigPathChanger *result;
18775 bool temp2 = false ;
18776 PyObject * obj0 = 0 ;
18777 PyObject * obj1 = 0 ;
18778 char *kwnames[] = {
18779 (char *) "config",(char *) "entry", NULL
18780 };
18781
18782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18784 if (SWIG_arg_fail(1)) SWIG_fail;
18785 {
18786 arg2 = wxString_in_helper(obj1);
18787 if (arg2 == NULL) SWIG_fail;
18788 temp2 = true;
18789 }
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18798 {
18799 if (temp2)
18800 delete arg2;
18801 }
18802 return resultobj;
18803 fail:
18804 {
18805 if (temp2)
18806 delete arg2;
18807 }
18808 return NULL;
18809 }
18810
18811
18812 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj;
18814 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18815 PyObject * obj0 = 0 ;
18816 char *kwnames[] = {
18817 (char *) "self", NULL
18818 };
18819
18820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18822 if (SWIG_arg_fail(1)) SWIG_fail;
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 delete arg1;
18826
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 Py_INCREF(Py_None); resultobj = Py_None;
18831 return resultobj;
18832 fail:
18833 return NULL;
18834 }
18835
18836
18837 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18838 PyObject *resultobj;
18839 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18840 wxString *result;
18841 PyObject * obj0 = 0 ;
18842 char *kwnames[] = {
18843 (char *) "self", NULL
18844 };
18845
18846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18848 if (SWIG_arg_fail(1)) SWIG_fail;
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 {
18852 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18853 result = (wxString *) &_result_ref;
18854 }
18855
18856 wxPyEndAllowThreads(__tstate);
18857 if (PyErr_Occurred()) SWIG_fail;
18858 }
18859 {
18860 #if wxUSE_UNICODE
18861 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18862 #else
18863 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18864 #endif
18865 }
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18873 PyObject *obj;
18874 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18875 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18876 Py_INCREF(obj);
18877 return Py_BuildValue((char *)"");
18878 }
18879 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18880 PyObject *resultobj;
18881 wxString *arg1 = 0 ;
18882 wxString result;
18883 bool temp1 = false ;
18884 PyObject * obj0 = 0 ;
18885 char *kwnames[] = {
18886 (char *) "sz", NULL
18887 };
18888
18889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18890 {
18891 arg1 = wxString_in_helper(obj0);
18892 if (arg1 == NULL) SWIG_fail;
18893 temp1 = true;
18894 }
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 result = wxExpandEnvVars((wxString const &)*arg1);
18898
18899 wxPyEndAllowThreads(__tstate);
18900 if (PyErr_Occurred()) SWIG_fail;
18901 }
18902 {
18903 #if wxUSE_UNICODE
18904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18905 #else
18906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18907 #endif
18908 }
18909 {
18910 if (temp1)
18911 delete arg1;
18912 }
18913 return resultobj;
18914 fail:
18915 {
18916 if (temp1)
18917 delete arg1;
18918 }
18919 return NULL;
18920 }
18921
18922
18923 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18924 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18925 return 1;
18926 }
18927
18928
18929 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18930 PyObject *pyobj;
18931
18932 {
18933 #if wxUSE_UNICODE
18934 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18935 #else
18936 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18937 #endif
18938 }
18939 return pyobj;
18940 }
18941
18942
18943 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18944 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18945 return 1;
18946 }
18947
18948
18949 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18950 PyObject *pyobj;
18951
18952 {
18953 #if wxUSE_UNICODE
18954 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18955 #else
18956 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18957 #endif
18958 }
18959 return pyobj;
18960 }
18961
18962
18963 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18964 PyObject *resultobj;
18965 wxDateTime::Country arg1 ;
18966 PyObject * obj0 = 0 ;
18967 char *kwnames[] = {
18968 (char *) "country", NULL
18969 };
18970
18971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18972 {
18973 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18974 if (SWIG_arg_fail(1)) SWIG_fail;
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18979
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 Py_INCREF(Py_None); resultobj = Py_None;
18984 return resultobj;
18985 fail:
18986 return NULL;
18987 }
18988
18989
18990 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18991 PyObject *resultobj;
18992 wxDateTime::Country result;
18993 char *kwnames[] = {
18994 NULL
18995 };
18996
18997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 result = (wxDateTime::Country)wxDateTime::GetCountry();
19001
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_From_int((result));
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj;
19014 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19015 bool result;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "country", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19022 if (obj0) {
19023 {
19024 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19025 if (SWIG_arg_fail(1)) SWIG_fail;
19026 }
19027 }
19028 {
19029 PyThreadState* __tstate = wxPyBeginAllowThreads();
19030 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19031
19032 wxPyEndAllowThreads(__tstate);
19033 if (PyErr_Occurred()) SWIG_fail;
19034 }
19035 {
19036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19037 }
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj;
19046 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19047 int result;
19048 PyObject * obj0 = 0 ;
19049 char *kwnames[] = {
19050 (char *) "cal", NULL
19051 };
19052
19053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19054 if (obj0) {
19055 {
19056 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19057 if (SWIG_arg_fail(1)) SWIG_fail;
19058 }
19059 }
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19063
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 {
19068 resultobj = SWIG_From_int((int)(result));
19069 }
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19077 PyObject *resultobj;
19078 int arg1 ;
19079 int result;
19080 PyObject * obj0 = 0 ;
19081 char *kwnames[] = {
19082 (char *) "year", NULL
19083 };
19084
19085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19086 {
19087 arg1 = (int)(SWIG_As_int(obj0));
19088 if (SWIG_arg_fail(1)) SWIG_fail;
19089 }
19090 {
19091 PyThreadState* __tstate = wxPyBeginAllowThreads();
19092 result = (int)wxDateTime::ConvertYearToBC(arg1);
19093
19094 wxPyEndAllowThreads(__tstate);
19095 if (PyErr_Occurred()) SWIG_fail;
19096 }
19097 {
19098 resultobj = SWIG_From_int((int)(result));
19099 }
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19109 wxDateTime::Month result;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "cal", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19116 if (obj0) {
19117 {
19118 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19119 if (SWIG_arg_fail(1)) SWIG_fail;
19120 }
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_From_int((result));
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 int arg1 = (int) wxDateTime::Inv_Year ;
19139 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19140 bool result;
19141 PyObject * obj0 = 0 ;
19142 PyObject * obj1 = 0 ;
19143 char *kwnames[] = {
19144 (char *) "year",(char *) "cal", NULL
19145 };
19146
19147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19148 if (obj0) {
19149 {
19150 arg1 = (int)(SWIG_As_int(obj0));
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 }
19153 }
19154 if (obj1) {
19155 {
19156 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19157 if (SWIG_arg_fail(2)) SWIG_fail;
19158 }
19159 }
19160 {
19161 PyThreadState* __tstate = wxPyBeginAllowThreads();
19162 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19163
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 {
19168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19169 }
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19177 PyObject *resultobj;
19178 int arg1 = (int) wxDateTime::Inv_Year ;
19179 int result;
19180 PyObject * obj0 = 0 ;
19181 char *kwnames[] = {
19182 (char *) "year", NULL
19183 };
19184
19185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19186 if (obj0) {
19187 {
19188 arg1 = (int)(SWIG_As_int(obj0));
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 }
19191 }
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (int)wxDateTime::GetCentury(arg1);
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = SWIG_From_int((int)(result));
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 int arg1 ;
19211 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19212 int result;
19213 PyObject * obj0 = 0 ;
19214 PyObject * obj1 = 0 ;
19215 char *kwnames[] = {
19216 (char *) "year",(char *) "cal", NULL
19217 };
19218
19219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19220 {
19221 arg1 = (int)(SWIG_As_int(obj0));
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 }
19224 if (obj1) {
19225 {
19226 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19227 if (SWIG_arg_fail(2)) SWIG_fail;
19228 }
19229 }
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19233
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 {
19238 resultobj = SWIG_From_int((int)(result));
19239 }
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 wxDateTime::Month arg1 ;
19249 int arg2 = (int) wxDateTime::Inv_Year ;
19250 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19251 int result;
19252 PyObject * obj0 = 0 ;
19253 PyObject * obj1 = 0 ;
19254 PyObject * obj2 = 0 ;
19255 char *kwnames[] = {
19256 (char *) "month",(char *) "year",(char *) "cal", NULL
19257 };
19258
19259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19260 {
19261 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 if (obj1) {
19265 {
19266 arg2 = (int)(SWIG_As_int(obj1));
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 }
19269 }
19270 if (obj2) {
19271 {
19272 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19273 if (SWIG_arg_fail(3)) SWIG_fail;
19274 }
19275 }
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19279
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 {
19284 resultobj = SWIG_From_int((int)(result));
19285 }
19286 return resultobj;
19287 fail:
19288 return NULL;
19289 }
19290
19291
19292 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19293 PyObject *resultobj;
19294 wxDateTime::Month arg1 ;
19295 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19296 wxString result;
19297 PyObject * obj0 = 0 ;
19298 PyObject * obj1 = 0 ;
19299 char *kwnames[] = {
19300 (char *) "month",(char *) "flags", NULL
19301 };
19302
19303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19304 {
19305 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19306 if (SWIG_arg_fail(1)) SWIG_fail;
19307 }
19308 if (obj1) {
19309 {
19310 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19311 if (SWIG_arg_fail(2)) SWIG_fail;
19312 }
19313 }
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19317
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 {
19322 #if wxUSE_UNICODE
19323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19324 #else
19325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19326 #endif
19327 }
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19335 PyObject *resultobj;
19336 wxDateTime::WeekDay arg1 ;
19337 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19338 wxString result;
19339 PyObject * obj0 = 0 ;
19340 PyObject * obj1 = 0 ;
19341 char *kwnames[] = {
19342 (char *) "weekday",(char *) "flags", NULL
19343 };
19344
19345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19346 {
19347 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19348 if (SWIG_arg_fail(1)) SWIG_fail;
19349 }
19350 if (obj1) {
19351 {
19352 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19353 if (SWIG_arg_fail(2)) SWIG_fail;
19354 }
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19359
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 {
19364 #if wxUSE_UNICODE
19365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19366 #else
19367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19368 #endif
19369 }
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj;
19378 PyObject *result;
19379 char *kwnames[] = {
19380 NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (PyObject *)DateTime_GetAmPmStrings();
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = result;
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 int arg1 = (int) wxDateTime::Inv_Year ;
19401 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19402 bool result;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "year",(char *) "country", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19410 if (obj0) {
19411 {
19412 arg1 = (int)(SWIG_As_int(obj0));
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 }
19415 }
19416 if (obj1) {
19417 {
19418 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 }
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 {
19430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19431 }
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj;
19440 int arg1 = (int) wxDateTime::Inv_Year ;
19441 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19442 wxDateTime result;
19443 PyObject * obj0 = 0 ;
19444 PyObject * obj1 = 0 ;
19445 char *kwnames[] = {
19446 (char *) "year",(char *) "country", NULL
19447 };
19448
19449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19450 if (obj0) {
19451 {
19452 arg1 = (int)(SWIG_As_int(obj0));
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 }
19455 }
19456 if (obj1) {
19457 {
19458 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19459 if (SWIG_arg_fail(2)) SWIG_fail;
19460 }
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19465
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 wxDateTime * resultptr;
19471 resultptr = new wxDateTime((wxDateTime &)(result));
19472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19473 }
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19481 PyObject *resultobj;
19482 int arg1 = (int) wxDateTime::Inv_Year ;
19483 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19484 wxDateTime result;
19485 PyObject * obj0 = 0 ;
19486 PyObject * obj1 = 0 ;
19487 char *kwnames[] = {
19488 (char *) "year",(char *) "country", NULL
19489 };
19490
19491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19492 if (obj0) {
19493 {
19494 arg1 = (int)(SWIG_As_int(obj0));
19495 if (SWIG_arg_fail(1)) SWIG_fail;
19496 }
19497 }
19498 if (obj1) {
19499 {
19500 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19501 if (SWIG_arg_fail(2)) SWIG_fail;
19502 }
19503 }
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19507
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 {
19512 wxDateTime * resultptr;
19513 resultptr = new wxDateTime((wxDateTime &)(result));
19514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19515 }
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19523 PyObject *resultobj;
19524 wxDateTime result;
19525 char *kwnames[] = {
19526 NULL
19527 };
19528
19529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19530 {
19531 PyThreadState* __tstate = wxPyBeginAllowThreads();
19532 result = wxDateTime::Now();
19533
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 {
19538 wxDateTime * resultptr;
19539 resultptr = new wxDateTime((wxDateTime &)(result));
19540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19541 }
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj;
19550 wxDateTime result;
19551 char *kwnames[] = {
19552 NULL
19553 };
19554
19555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = wxDateTime::UNow();
19559
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 {
19564 wxDateTime * resultptr;
19565 resultptr = new wxDateTime((wxDateTime &)(result));
19566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19567 }
19568 return resultobj;
19569 fail:
19570 return NULL;
19571 }
19572
19573
19574 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19575 PyObject *resultobj;
19576 wxDateTime result;
19577 char *kwnames[] = {
19578 NULL
19579 };
19580
19581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 result = wxDateTime::Today();
19585
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 {
19590 wxDateTime * resultptr;
19591 resultptr = new wxDateTime((wxDateTime &)(result));
19592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19593 }
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj;
19602 wxDateTime *result;
19603 char *kwnames[] = {
19604 NULL
19605 };
19606
19607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 result = (wxDateTime *)new wxDateTime();
19611
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj;
19624 time_t arg1 ;
19625 wxDateTime *result;
19626 PyObject * obj0 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "timet", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19632 {
19633 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 }
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = (wxDateTime *)new wxDateTime(arg1);
19639
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19644 return resultobj;
19645 fail:
19646 return NULL;
19647 }
19648
19649
19650 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19651 PyObject *resultobj;
19652 double arg1 ;
19653 wxDateTime *result;
19654 PyObject * obj0 = 0 ;
19655 char *kwnames[] = {
19656 (char *) "jdn", NULL
19657 };
19658
19659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19660 {
19661 arg1 = (double)(SWIG_As_double(obj0));
19662 if (SWIG_arg_fail(1)) SWIG_fail;
19663 }
19664 {
19665 PyThreadState* __tstate = wxPyBeginAllowThreads();
19666 result = (wxDateTime *)new wxDateTime(arg1);
19667
19668 wxPyEndAllowThreads(__tstate);
19669 if (PyErr_Occurred()) SWIG_fail;
19670 }
19671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19672 return resultobj;
19673 fail:
19674 return NULL;
19675 }
19676
19677
19678 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19679 PyObject *resultobj;
19680 int arg1 ;
19681 int arg2 = (int) 0 ;
19682 int arg3 = (int) 0 ;
19683 int arg4 = (int) 0 ;
19684 wxDateTime *result;
19685 PyObject * obj0 = 0 ;
19686 PyObject * obj1 = 0 ;
19687 PyObject * obj2 = 0 ;
19688 PyObject * obj3 = 0 ;
19689 char *kwnames[] = {
19690 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19691 };
19692
19693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19694 {
19695 arg1 = (int)(SWIG_As_int(obj0));
19696 if (SWIG_arg_fail(1)) SWIG_fail;
19697 }
19698 if (obj1) {
19699 {
19700 arg2 = (int)(SWIG_As_int(obj1));
19701 if (SWIG_arg_fail(2)) SWIG_fail;
19702 }
19703 }
19704 if (obj2) {
19705 {
19706 arg3 = (int)(SWIG_As_int(obj2));
19707 if (SWIG_arg_fail(3)) SWIG_fail;
19708 }
19709 }
19710 if (obj3) {
19711 {
19712 arg4 = (int)(SWIG_As_int(obj3));
19713 if (SWIG_arg_fail(4)) SWIG_fail;
19714 }
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19731 PyObject *resultobj;
19732 int arg1 ;
19733 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19734 int arg3 = (int) wxDateTime::Inv_Year ;
19735 int arg4 = (int) 0 ;
19736 int arg5 = (int) 0 ;
19737 int arg6 = (int) 0 ;
19738 int arg7 = (int) 0 ;
19739 wxDateTime *result;
19740 PyObject * obj0 = 0 ;
19741 PyObject * obj1 = 0 ;
19742 PyObject * obj2 = 0 ;
19743 PyObject * obj3 = 0 ;
19744 PyObject * obj4 = 0 ;
19745 PyObject * obj5 = 0 ;
19746 PyObject * obj6 = 0 ;
19747 char *kwnames[] = {
19748 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19749 };
19750
19751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19752 {
19753 arg1 = (int)(SWIG_As_int(obj0));
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 }
19756 if (obj1) {
19757 {
19758 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19759 if (SWIG_arg_fail(2)) SWIG_fail;
19760 }
19761 }
19762 if (obj2) {
19763 {
19764 arg3 = (int)(SWIG_As_int(obj2));
19765 if (SWIG_arg_fail(3)) SWIG_fail;
19766 }
19767 }
19768 if (obj3) {
19769 {
19770 arg4 = (int)(SWIG_As_int(obj3));
19771 if (SWIG_arg_fail(4)) SWIG_fail;
19772 }
19773 }
19774 if (obj4) {
19775 {
19776 arg5 = (int)(SWIG_As_int(obj4));
19777 if (SWIG_arg_fail(5)) SWIG_fail;
19778 }
19779 }
19780 if (obj5) {
19781 {
19782 arg6 = (int)(SWIG_As_int(obj5));
19783 if (SWIG_arg_fail(6)) SWIG_fail;
19784 }
19785 }
19786 if (obj6) {
19787 {
19788 arg7 = (int)(SWIG_As_int(obj6));
19789 if (SWIG_arg_fail(7)) SWIG_fail;
19790 }
19791 }
19792 {
19793 PyThreadState* __tstate = wxPyBeginAllowThreads();
19794 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19795
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj;
19808 wxDateTime *arg1 = (wxDateTime *) 0 ;
19809 PyObject * obj0 = 0 ;
19810 char *kwnames[] = {
19811 (char *) "self", NULL
19812 };
19813
19814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19816 if (SWIG_arg_fail(1)) SWIG_fail;
19817 {
19818 PyThreadState* __tstate = wxPyBeginAllowThreads();
19819 delete arg1;
19820
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 Py_INCREF(Py_None); resultobj = Py_None;
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxDateTime *arg1 = (wxDateTime *) 0 ;
19834 wxDateTime *result;
19835 PyObject * obj0 = 0 ;
19836 char *kwnames[] = {
19837 (char *) "self", NULL
19838 };
19839
19840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19842 if (SWIG_arg_fail(1)) SWIG_fail;
19843 {
19844 PyThreadState* __tstate = wxPyBeginAllowThreads();
19845 {
19846 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19847 result = (wxDateTime *) &_result_ref;
19848 }
19849
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19861 PyObject *resultobj;
19862 wxDateTime *arg1 = (wxDateTime *) 0 ;
19863 time_t arg2 ;
19864 wxDateTime *result;
19865 PyObject * obj0 = 0 ;
19866 PyObject * obj1 = 0 ;
19867 char *kwnames[] = {
19868 (char *) "self",(char *) "timet", NULL
19869 };
19870
19871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19873 if (SWIG_arg_fail(1)) SWIG_fail;
19874 {
19875 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19876 if (SWIG_arg_fail(2)) SWIG_fail;
19877 }
19878 {
19879 PyThreadState* __tstate = wxPyBeginAllowThreads();
19880 {
19881 wxDateTime &_result_ref = (arg1)->Set(arg2);
19882 result = (wxDateTime *) &_result_ref;
19883 }
19884
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19889 return resultobj;
19890 fail:
19891 return NULL;
19892 }
19893
19894
19895 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19896 PyObject *resultobj;
19897 wxDateTime *arg1 = (wxDateTime *) 0 ;
19898 double arg2 ;
19899 wxDateTime *result;
19900 PyObject * obj0 = 0 ;
19901 PyObject * obj1 = 0 ;
19902 char *kwnames[] = {
19903 (char *) "self",(char *) "jdn", NULL
19904 };
19905
19906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19908 if (SWIG_arg_fail(1)) SWIG_fail;
19909 {
19910 arg2 = (double)(SWIG_As_double(obj1));
19911 if (SWIG_arg_fail(2)) SWIG_fail;
19912 }
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 {
19916 wxDateTime &_result_ref = (arg1)->Set(arg2);
19917 result = (wxDateTime *) &_result_ref;
19918 }
19919
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxDateTime *arg1 = (wxDateTime *) 0 ;
19933 int arg2 ;
19934 int arg3 = (int) 0 ;
19935 int arg4 = (int) 0 ;
19936 int arg5 = (int) 0 ;
19937 wxDateTime *result;
19938 PyObject * obj0 = 0 ;
19939 PyObject * obj1 = 0 ;
19940 PyObject * obj2 = 0 ;
19941 PyObject * obj3 = 0 ;
19942 PyObject * obj4 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(1)) SWIG_fail;
19950 {
19951 arg2 = (int)(SWIG_As_int(obj1));
19952 if (SWIG_arg_fail(2)) SWIG_fail;
19953 }
19954 if (obj2) {
19955 {
19956 arg3 = (int)(SWIG_As_int(obj2));
19957 if (SWIG_arg_fail(3)) SWIG_fail;
19958 }
19959 }
19960 if (obj3) {
19961 {
19962 arg4 = (int)(SWIG_As_int(obj3));
19963 if (SWIG_arg_fail(4)) SWIG_fail;
19964 }
19965 }
19966 if (obj4) {
19967 {
19968 arg5 = (int)(SWIG_As_int(obj4));
19969 if (SWIG_arg_fail(5)) SWIG_fail;
19970 }
19971 }
19972 {
19973 PyThreadState* __tstate = wxPyBeginAllowThreads();
19974 {
19975 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19976 result = (wxDateTime *) &_result_ref;
19977 }
19978
19979 wxPyEndAllowThreads(__tstate);
19980 if (PyErr_Occurred()) SWIG_fail;
19981 }
19982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19990 PyObject *resultobj;
19991 wxDateTime *arg1 = (wxDateTime *) 0 ;
19992 int arg2 ;
19993 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19994 int arg4 = (int) wxDateTime::Inv_Year ;
19995 int arg5 = (int) 0 ;
19996 int arg6 = (int) 0 ;
19997 int arg7 = (int) 0 ;
19998 int arg8 = (int) 0 ;
19999 wxDateTime *result;
20000 PyObject * obj0 = 0 ;
20001 PyObject * obj1 = 0 ;
20002 PyObject * obj2 = 0 ;
20003 PyObject * obj3 = 0 ;
20004 PyObject * obj4 = 0 ;
20005 PyObject * obj5 = 0 ;
20006 PyObject * obj6 = 0 ;
20007 PyObject * obj7 = 0 ;
20008 char *kwnames[] = {
20009 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20010 };
20011
20012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20014 if (SWIG_arg_fail(1)) SWIG_fail;
20015 {
20016 arg2 = (int)(SWIG_As_int(obj1));
20017 if (SWIG_arg_fail(2)) SWIG_fail;
20018 }
20019 if (obj2) {
20020 {
20021 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20022 if (SWIG_arg_fail(3)) SWIG_fail;
20023 }
20024 }
20025 if (obj3) {
20026 {
20027 arg4 = (int)(SWIG_As_int(obj3));
20028 if (SWIG_arg_fail(4)) SWIG_fail;
20029 }
20030 }
20031 if (obj4) {
20032 {
20033 arg5 = (int)(SWIG_As_int(obj4));
20034 if (SWIG_arg_fail(5)) SWIG_fail;
20035 }
20036 }
20037 if (obj5) {
20038 {
20039 arg6 = (int)(SWIG_As_int(obj5));
20040 if (SWIG_arg_fail(6)) SWIG_fail;
20041 }
20042 }
20043 if (obj6) {
20044 {
20045 arg7 = (int)(SWIG_As_int(obj6));
20046 if (SWIG_arg_fail(7)) SWIG_fail;
20047 }
20048 }
20049 if (obj7) {
20050 {
20051 arg8 = (int)(SWIG_As_int(obj7));
20052 if (SWIG_arg_fail(8)) SWIG_fail;
20053 }
20054 }
20055 {
20056 PyThreadState* __tstate = wxPyBeginAllowThreads();
20057 {
20058 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20059 result = (wxDateTime *) &_result_ref;
20060 }
20061
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20073 PyObject *resultobj;
20074 wxDateTime *arg1 = (wxDateTime *) 0 ;
20075 wxDateTime *result;
20076 PyObject * obj0 = 0 ;
20077 char *kwnames[] = {
20078 (char *) "self", NULL
20079 };
20080
20081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 {
20087 wxDateTime &_result_ref = (arg1)->ResetTime();
20088 result = (wxDateTime *) &_result_ref;
20089 }
20090
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20102 PyObject *resultobj;
20103 wxDateTime *arg1 = (wxDateTime *) 0 ;
20104 int arg2 ;
20105 wxDateTime *result;
20106 PyObject * obj0 = 0 ;
20107 PyObject * obj1 = 0 ;
20108 char *kwnames[] = {
20109 (char *) "self",(char *) "year", NULL
20110 };
20111
20112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20114 if (SWIG_arg_fail(1)) SWIG_fail;
20115 {
20116 arg2 = (int)(SWIG_As_int(obj1));
20117 if (SWIG_arg_fail(2)) SWIG_fail;
20118 }
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 {
20122 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20123 result = (wxDateTime *) &_result_ref;
20124 }
20125
20126 wxPyEndAllowThreads(__tstate);
20127 if (PyErr_Occurred()) SWIG_fail;
20128 }
20129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20137 PyObject *resultobj;
20138 wxDateTime *arg1 = (wxDateTime *) 0 ;
20139 wxDateTime::Month arg2 ;
20140 wxDateTime *result;
20141 PyObject * obj0 = 0 ;
20142 PyObject * obj1 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "self",(char *) "month", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 {
20151 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20152 if (SWIG_arg_fail(2)) SWIG_fail;
20153 }
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 {
20157 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20158 result = (wxDateTime *) &_result_ref;
20159 }
20160
20161 wxPyEndAllowThreads(__tstate);
20162 if (PyErr_Occurred()) SWIG_fail;
20163 }
20164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20165 return resultobj;
20166 fail:
20167 return NULL;
20168 }
20169
20170
20171 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20172 PyObject *resultobj;
20173 wxDateTime *arg1 = (wxDateTime *) 0 ;
20174 int arg2 ;
20175 wxDateTime *result;
20176 PyObject * obj0 = 0 ;
20177 PyObject * obj1 = 0 ;
20178 char *kwnames[] = {
20179 (char *) "self",(char *) "day", NULL
20180 };
20181
20182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20184 if (SWIG_arg_fail(1)) SWIG_fail;
20185 {
20186 arg2 = (int)(SWIG_As_int(obj1));
20187 if (SWIG_arg_fail(2)) SWIG_fail;
20188 }
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 {
20192 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20193 result = (wxDateTime *) &_result_ref;
20194 }
20195
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20207 PyObject *resultobj;
20208 wxDateTime *arg1 = (wxDateTime *) 0 ;
20209 int arg2 ;
20210 wxDateTime *result;
20211 PyObject * obj0 = 0 ;
20212 PyObject * obj1 = 0 ;
20213 char *kwnames[] = {
20214 (char *) "self",(char *) "hour", NULL
20215 };
20216
20217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20219 if (SWIG_arg_fail(1)) SWIG_fail;
20220 {
20221 arg2 = (int)(SWIG_As_int(obj1));
20222 if (SWIG_arg_fail(2)) SWIG_fail;
20223 }
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 {
20227 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20228 result = (wxDateTime *) &_result_ref;
20229 }
20230
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj;
20243 wxDateTime *arg1 = (wxDateTime *) 0 ;
20244 int arg2 ;
20245 wxDateTime *result;
20246 PyObject * obj0 = 0 ;
20247 PyObject * obj1 = 0 ;
20248 char *kwnames[] = {
20249 (char *) "self",(char *) "minute", NULL
20250 };
20251
20252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20254 if (SWIG_arg_fail(1)) SWIG_fail;
20255 {
20256 arg2 = (int)(SWIG_As_int(obj1));
20257 if (SWIG_arg_fail(2)) SWIG_fail;
20258 }
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 {
20262 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20263 result = (wxDateTime *) &_result_ref;
20264 }
20265
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxDateTime *arg1 = (wxDateTime *) 0 ;
20279 int arg2 ;
20280 wxDateTime *result;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char *kwnames[] = {
20284 (char *) "self",(char *) "second", NULL
20285 };
20286
20287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20289 if (SWIG_arg_fail(1)) SWIG_fail;
20290 {
20291 arg2 = (int)(SWIG_As_int(obj1));
20292 if (SWIG_arg_fail(2)) SWIG_fail;
20293 }
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 {
20297 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20298 result = (wxDateTime *) &_result_ref;
20299 }
20300
20301 wxPyEndAllowThreads(__tstate);
20302 if (PyErr_Occurred()) SWIG_fail;
20303 }
20304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj;
20313 wxDateTime *arg1 = (wxDateTime *) 0 ;
20314 int arg2 ;
20315 wxDateTime *result;
20316 PyObject * obj0 = 0 ;
20317 PyObject * obj1 = 0 ;
20318 char *kwnames[] = {
20319 (char *) "self",(char *) "millisecond", NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(1)) SWIG_fail;
20325 {
20326 arg2 = (int)(SWIG_As_int(obj1));
20327 if (SWIG_arg_fail(2)) SWIG_fail;
20328 }
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 {
20332 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20333 result = (wxDateTime *) &_result_ref;
20334 }
20335
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj;
20348 wxDateTime *arg1 = (wxDateTime *) 0 ;
20349 wxDateTime::WeekDay arg2 ;
20350 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20351 wxDateTime *result;
20352 PyObject * obj0 = 0 ;
20353 PyObject * obj1 = 0 ;
20354 PyObject * obj2 = 0 ;
20355 char *kwnames[] = {
20356 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20357 };
20358
20359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20361 if (SWIG_arg_fail(1)) SWIG_fail;
20362 {
20363 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20364 if (SWIG_arg_fail(2)) SWIG_fail;
20365 }
20366 if (obj2) {
20367 {
20368 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20369 if (SWIG_arg_fail(3)) SWIG_fail;
20370 }
20371 }
20372 {
20373 PyThreadState* __tstate = wxPyBeginAllowThreads();
20374 {
20375 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20376 result = (wxDateTime *) &_result_ref;
20377 }
20378
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj;
20391 wxDateTime *arg1 = (wxDateTime *) 0 ;
20392 wxDateTime::WeekDay arg2 ;
20393 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20394 wxDateTime result;
20395 PyObject * obj0 = 0 ;
20396 PyObject * obj1 = 0 ;
20397 PyObject * obj2 = 0 ;
20398 char *kwnames[] = {
20399 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20400 };
20401
20402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20404 if (SWIG_arg_fail(1)) SWIG_fail;
20405 {
20406 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20407 if (SWIG_arg_fail(2)) SWIG_fail;
20408 }
20409 if (obj2) {
20410 {
20411 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20412 if (SWIG_arg_fail(3)) SWIG_fail;
20413 }
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 wxDateTime * resultptr;
20424 resultptr = new wxDateTime((wxDateTime &)(result));
20425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20426 }
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20434 PyObject *resultobj;
20435 wxDateTime *arg1 = (wxDateTime *) 0 ;
20436 wxDateTime::WeekDay arg2 ;
20437 wxDateTime *result;
20438 PyObject * obj0 = 0 ;
20439 PyObject * obj1 = 0 ;
20440 char *kwnames[] = {
20441 (char *) "self",(char *) "weekday", NULL
20442 };
20443
20444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20446 if (SWIG_arg_fail(1)) SWIG_fail;
20447 {
20448 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20449 if (SWIG_arg_fail(2)) SWIG_fail;
20450 }
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 {
20454 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20455 result = (wxDateTime *) &_result_ref;
20456 }
20457
20458 wxPyEndAllowThreads(__tstate);
20459 if (PyErr_Occurred()) SWIG_fail;
20460 }
20461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20462 return resultobj;
20463 fail:
20464 return NULL;
20465 }
20466
20467
20468 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20469 PyObject *resultobj;
20470 wxDateTime *arg1 = (wxDateTime *) 0 ;
20471 wxDateTime::WeekDay arg2 ;
20472 wxDateTime result;
20473 PyObject * obj0 = 0 ;
20474 PyObject * obj1 = 0 ;
20475 char *kwnames[] = {
20476 (char *) "self",(char *) "weekday", NULL
20477 };
20478
20479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20481 if (SWIG_arg_fail(1)) SWIG_fail;
20482 {
20483 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20484 if (SWIG_arg_fail(2)) SWIG_fail;
20485 }
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 {
20494 wxDateTime * resultptr;
20495 resultptr = new wxDateTime((wxDateTime &)(result));
20496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj;
20506 wxDateTime *arg1 = (wxDateTime *) 0 ;
20507 wxDateTime::WeekDay arg2 ;
20508 wxDateTime *result;
20509 PyObject * obj0 = 0 ;
20510 PyObject * obj1 = 0 ;
20511 char *kwnames[] = {
20512 (char *) "self",(char *) "weekday", NULL
20513 };
20514
20515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20517 if (SWIG_arg_fail(1)) SWIG_fail;
20518 {
20519 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20520 if (SWIG_arg_fail(2)) SWIG_fail;
20521 }
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 {
20525 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20526 result = (wxDateTime *) &_result_ref;
20527 }
20528
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20540 PyObject *resultobj;
20541 wxDateTime *arg1 = (wxDateTime *) 0 ;
20542 wxDateTime::WeekDay arg2 ;
20543 wxDateTime result;
20544 PyObject * obj0 = 0 ;
20545 PyObject * obj1 = 0 ;
20546 char *kwnames[] = {
20547 (char *) "self",(char *) "weekday", NULL
20548 };
20549
20550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20552 if (SWIG_arg_fail(1)) SWIG_fail;
20553 {
20554 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20555 if (SWIG_arg_fail(2)) SWIG_fail;
20556 }
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20560
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 wxDateTime * resultptr;
20566 resultptr = new wxDateTime((wxDateTime &)(result));
20567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj;
20577 wxDateTime *arg1 = (wxDateTime *) 0 ;
20578 wxDateTime::WeekDay arg2 ;
20579 int arg3 = (int) 1 ;
20580 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20581 int arg5 = (int) wxDateTime::Inv_Year ;
20582 bool result;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 PyObject * obj2 = 0 ;
20586 PyObject * obj3 = 0 ;
20587 PyObject * obj4 = 0 ;
20588 char *kwnames[] = {
20589 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 {
20596 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20597 if (SWIG_arg_fail(2)) SWIG_fail;
20598 }
20599 if (obj2) {
20600 {
20601 arg3 = (int)(SWIG_As_int(obj2));
20602 if (SWIG_arg_fail(3)) SWIG_fail;
20603 }
20604 }
20605 if (obj3) {
20606 {
20607 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20608 if (SWIG_arg_fail(4)) SWIG_fail;
20609 }
20610 }
20611 if (obj4) {
20612 {
20613 arg5 = (int)(SWIG_As_int(obj4));
20614 if (SWIG_arg_fail(5)) SWIG_fail;
20615 }
20616 }
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20620
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxDateTime *arg1 = (wxDateTime *) 0 ;
20636 wxDateTime::WeekDay arg2 ;
20637 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20638 int arg4 = (int) wxDateTime::Inv_Year ;
20639 bool result;
20640 PyObject * obj0 = 0 ;
20641 PyObject * obj1 = 0 ;
20642 PyObject * obj2 = 0 ;
20643 PyObject * obj3 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20650 if (SWIG_arg_fail(1)) SWIG_fail;
20651 {
20652 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20653 if (SWIG_arg_fail(2)) SWIG_fail;
20654 }
20655 if (obj2) {
20656 {
20657 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20658 if (SWIG_arg_fail(3)) SWIG_fail;
20659 }
20660 }
20661 if (obj3) {
20662 {
20663 arg4 = (int)(SWIG_As_int(obj3));
20664 if (SWIG_arg_fail(4)) SWIG_fail;
20665 }
20666 }
20667 {
20668 PyThreadState* __tstate = wxPyBeginAllowThreads();
20669 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20670
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 {
20675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj;
20685 wxDateTime *arg1 = (wxDateTime *) 0 ;
20686 wxDateTime::WeekDay arg2 ;
20687 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20688 int arg4 = (int) wxDateTime::Inv_Year ;
20689 wxDateTime result;
20690 PyObject * obj0 = 0 ;
20691 PyObject * obj1 = 0 ;
20692 PyObject * obj2 = 0 ;
20693 PyObject * obj3 = 0 ;
20694 char *kwnames[] = {
20695 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20696 };
20697
20698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20700 if (SWIG_arg_fail(1)) SWIG_fail;
20701 {
20702 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20703 if (SWIG_arg_fail(2)) SWIG_fail;
20704 }
20705 if (obj2) {
20706 {
20707 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20708 if (SWIG_arg_fail(3)) SWIG_fail;
20709 }
20710 }
20711 if (obj3) {
20712 {
20713 arg4 = (int)(SWIG_As_int(obj3));
20714 if (SWIG_arg_fail(4)) SWIG_fail;
20715 }
20716 }
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20720
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 wxDateTime * resultptr;
20726 resultptr = new wxDateTime((wxDateTime &)(result));
20727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDateTime *arg1 = (wxDateTime *) 0 ;
20738 int arg2 ;
20739 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20740 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20741 bool result;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 PyObject * obj2 = 0 ;
20745 PyObject * obj3 = 0 ;
20746 char *kwnames[] = {
20747 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20748 };
20749
20750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20752 if (SWIG_arg_fail(1)) SWIG_fail;
20753 {
20754 arg2 = (int)(SWIG_As_int(obj1));
20755 if (SWIG_arg_fail(2)) SWIG_fail;
20756 }
20757 if (obj2) {
20758 {
20759 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20760 if (SWIG_arg_fail(3)) SWIG_fail;
20761 }
20762 }
20763 if (obj3) {
20764 {
20765 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20766 if (SWIG_arg_fail(4)) SWIG_fail;
20767 }
20768 }
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20772
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj;
20787 wxDateTime *arg1 = (wxDateTime *) 0 ;
20788 int arg2 ;
20789 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20790 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20791 wxDateTime result;
20792 PyObject * obj0 = 0 ;
20793 PyObject * obj1 = 0 ;
20794 PyObject * obj2 = 0 ;
20795 PyObject * obj3 = 0 ;
20796 char *kwnames[] = {
20797 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20798 };
20799
20800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20802 if (SWIG_arg_fail(1)) SWIG_fail;
20803 {
20804 arg2 = (int)(SWIG_As_int(obj1));
20805 if (SWIG_arg_fail(2)) SWIG_fail;
20806 }
20807 if (obj2) {
20808 {
20809 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20810 if (SWIG_arg_fail(3)) SWIG_fail;
20811 }
20812 }
20813 if (obj3) {
20814 {
20815 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20816 if (SWIG_arg_fail(4)) SWIG_fail;
20817 }
20818 }
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20822
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 wxDateTime * resultptr;
20828 resultptr = new wxDateTime((wxDateTime &)(result));
20829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20830 }
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20838 PyObject *resultobj;
20839 int arg1 ;
20840 int arg2 ;
20841 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20842 wxDateTime result;
20843 PyObject * obj0 = 0 ;
20844 PyObject * obj1 = 0 ;
20845 PyObject * obj2 = 0 ;
20846 char *kwnames[] = {
20847 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20851 {
20852 arg1 = (int)(SWIG_As_int(obj0));
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 }
20855 {
20856 arg2 = (int)(SWIG_As_int(obj1));
20857 if (SWIG_arg_fail(2)) SWIG_fail;
20858 }
20859 if (obj2) {
20860 {
20861 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20862 if (SWIG_arg_fail(3)) SWIG_fail;
20863 }
20864 }
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20868
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 wxDateTime * resultptr;
20874 resultptr = new wxDateTime((wxDateTime &)(result));
20875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20876 }
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20884 PyObject *resultobj;
20885 wxDateTime *arg1 = (wxDateTime *) 0 ;
20886 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20887 int arg3 = (int) wxDateTime::Inv_Year ;
20888 wxDateTime *result;
20889 PyObject * obj0 = 0 ;
20890 PyObject * obj1 = 0 ;
20891 PyObject * obj2 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self",(char *) "month",(char *) "year", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 if (obj1) {
20900 {
20901 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20902 if (SWIG_arg_fail(2)) SWIG_fail;
20903 }
20904 }
20905 if (obj2) {
20906 {
20907 arg3 = (int)(SWIG_As_int(obj2));
20908 if (SWIG_arg_fail(3)) SWIG_fail;
20909 }
20910 }
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 {
20914 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20915 result = (wxDateTime *) &_result_ref;
20916 }
20917
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj;
20930 wxDateTime *arg1 = (wxDateTime *) 0 ;
20931 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20932 int arg3 = (int) wxDateTime::Inv_Year ;
20933 wxDateTime result;
20934 PyObject * obj0 = 0 ;
20935 PyObject * obj1 = 0 ;
20936 PyObject * obj2 = 0 ;
20937 char *kwnames[] = {
20938 (char *) "self",(char *) "month",(char *) "year", NULL
20939 };
20940
20941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20943 if (SWIG_arg_fail(1)) SWIG_fail;
20944 if (obj1) {
20945 {
20946 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20947 if (SWIG_arg_fail(2)) SWIG_fail;
20948 }
20949 }
20950 if (obj2) {
20951 {
20952 arg3 = (int)(SWIG_As_int(obj2));
20953 if (SWIG_arg_fail(3)) SWIG_fail;
20954 }
20955 }
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20959
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 wxDateTime * resultptr;
20965 resultptr = new wxDateTime((wxDateTime &)(result));
20966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20967 }
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20975 PyObject *resultobj;
20976 wxDateTime *arg1 = (wxDateTime *) 0 ;
20977 int arg2 ;
20978 wxDateTime *result;
20979 PyObject * obj0 = 0 ;
20980 PyObject * obj1 = 0 ;
20981 char *kwnames[] = {
20982 (char *) "self",(char *) "yday", NULL
20983 };
20984
20985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20987 if (SWIG_arg_fail(1)) SWIG_fail;
20988 {
20989 arg2 = (int)(SWIG_As_int(obj1));
20990 if (SWIG_arg_fail(2)) SWIG_fail;
20991 }
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 {
20995 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20996 result = (wxDateTime *) &_result_ref;
20997 }
20998
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj;
21011 wxDateTime *arg1 = (wxDateTime *) 0 ;
21012 int arg2 ;
21013 wxDateTime result;
21014 PyObject * obj0 = 0 ;
21015 PyObject * obj1 = 0 ;
21016 char *kwnames[] = {
21017 (char *) "self",(char *) "yday", NULL
21018 };
21019
21020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21022 if (SWIG_arg_fail(1)) SWIG_fail;
21023 {
21024 arg2 = (int)(SWIG_As_int(obj1));
21025 if (SWIG_arg_fail(2)) SWIG_fail;
21026 }
21027 {
21028 PyThreadState* __tstate = wxPyBeginAllowThreads();
21029 result = (arg1)->GetYearDay(arg2);
21030
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 wxDateTime * resultptr;
21036 resultptr = new wxDateTime((wxDateTime &)(result));
21037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21038 }
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj;
21047 wxDateTime *arg1 = (wxDateTime *) 0 ;
21048 double result;
21049 PyObject * obj0 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 PyThreadState* __tstate = wxPyBeginAllowThreads();
21059 result = (double)(arg1)->GetJulianDayNumber();
21060
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 resultobj = SWIG_From_double((double)(result));
21066 }
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21074 PyObject *resultobj;
21075 wxDateTime *arg1 = (wxDateTime *) 0 ;
21076 double result;
21077 PyObject * obj0 = 0 ;
21078 char *kwnames[] = {
21079 (char *) "self", NULL
21080 };
21081
21082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21084 if (SWIG_arg_fail(1)) SWIG_fail;
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 result = (double)(arg1)->GetJDN();
21088
21089 wxPyEndAllowThreads(__tstate);
21090 if (PyErr_Occurred()) SWIG_fail;
21091 }
21092 {
21093 resultobj = SWIG_From_double((double)(result));
21094 }
21095 return resultobj;
21096 fail:
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 wxDateTime *arg1 = (wxDateTime *) 0 ;
21104 double result;
21105 PyObject * obj0 = 0 ;
21106 char *kwnames[] = {
21107 (char *) "self", NULL
21108 };
21109
21110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21116
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 {
21121 resultobj = SWIG_From_double((double)(result));
21122 }
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21130 PyObject *resultobj;
21131 wxDateTime *arg1 = (wxDateTime *) 0 ;
21132 double result;
21133 PyObject * obj0 = 0 ;
21134 char *kwnames[] = {
21135 (char *) "self", NULL
21136 };
21137
21138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21140 if (SWIG_arg_fail(1)) SWIG_fail;
21141 {
21142 PyThreadState* __tstate = wxPyBeginAllowThreads();
21143 result = (double)(arg1)->GetMJD();
21144
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 {
21149 resultobj = SWIG_From_double((double)(result));
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21158 PyObject *resultobj;
21159 wxDateTime *arg1 = (wxDateTime *) 0 ;
21160 double result;
21161 PyObject * obj0 = 0 ;
21162 char *kwnames[] = {
21163 (char *) "self", NULL
21164 };
21165
21166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21168 if (SWIG_arg_fail(1)) SWIG_fail;
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = (double)(arg1)->GetRataDie();
21172
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 {
21177 resultobj = SWIG_From_double((double)(result));
21178 }
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj;
21187 wxDateTime *arg1 = (wxDateTime *) 0 ;
21188 wxDateTime::TimeZone *arg2 = 0 ;
21189 bool arg3 = (bool) false ;
21190 wxDateTime result;
21191 bool temp2 = false ;
21192 PyObject * obj0 = 0 ;
21193 PyObject * obj1 = 0 ;
21194 PyObject * obj2 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21204 temp2 = true;
21205 }
21206 if (obj2) {
21207 {
21208 arg3 = (bool)(SWIG_As_bool(obj2));
21209 if (SWIG_arg_fail(3)) SWIG_fail;
21210 }
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21215
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 {
21220 wxDateTime * resultptr;
21221 resultptr = new wxDateTime((wxDateTime &)(result));
21222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21223 }
21224 {
21225 if (temp2) delete arg2;
21226 }
21227 return resultobj;
21228 fail:
21229 {
21230 if (temp2) delete arg2;
21231 }
21232 return NULL;
21233 }
21234
21235
21236 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxDateTime *arg1 = (wxDateTime *) 0 ;
21239 wxDateTime::TimeZone *arg2 = 0 ;
21240 bool arg3 = (bool) false ;
21241 wxDateTime *result;
21242 bool temp2 = false ;
21243 PyObject * obj0 = 0 ;
21244 PyObject * obj1 = 0 ;
21245 PyObject * obj2 = 0 ;
21246 char *kwnames[] = {
21247 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21248 };
21249
21250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21252 if (SWIG_arg_fail(1)) SWIG_fail;
21253 {
21254 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21255 temp2 = true;
21256 }
21257 if (obj2) {
21258 {
21259 arg3 = (bool)(SWIG_As_bool(obj2));
21260 if (SWIG_arg_fail(3)) SWIG_fail;
21261 }
21262 }
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 {
21266 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21267 result = (wxDateTime *) &_result_ref;
21268 }
21269
21270 wxPyEndAllowThreads(__tstate);
21271 if (PyErr_Occurred()) SWIG_fail;
21272 }
21273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21274 {
21275 if (temp2) delete arg2;
21276 }
21277 return resultobj;
21278 fail:
21279 {
21280 if (temp2) delete arg2;
21281 }
21282 return NULL;
21283 }
21284
21285
21286 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 wxDateTime *arg1 = (wxDateTime *) 0 ;
21289 bool arg2 = (bool) false ;
21290 wxDateTime result;
21291 PyObject * obj0 = 0 ;
21292 PyObject * obj1 = 0 ;
21293 char *kwnames[] = {
21294 (char *) "self",(char *) "noDST", NULL
21295 };
21296
21297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21299 if (SWIG_arg_fail(1)) SWIG_fail;
21300 if (obj1) {
21301 {
21302 arg2 = (bool)(SWIG_As_bool(obj1));
21303 if (SWIG_arg_fail(2)) SWIG_fail;
21304 }
21305 }
21306 {
21307 PyThreadState* __tstate = wxPyBeginAllowThreads();
21308 result = (arg1)->ToGMT(arg2);
21309
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 {
21314 wxDateTime * resultptr;
21315 resultptr = new wxDateTime((wxDateTime &)(result));
21316 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21317 }
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj;
21326 wxDateTime *arg1 = (wxDateTime *) 0 ;
21327 bool arg2 = (bool) false ;
21328 wxDateTime *result;
21329 PyObject * obj0 = 0 ;
21330 PyObject * obj1 = 0 ;
21331 char *kwnames[] = {
21332 (char *) "self",(char *) "noDST", NULL
21333 };
21334
21335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21337 if (SWIG_arg_fail(1)) SWIG_fail;
21338 if (obj1) {
21339 {
21340 arg2 = (bool)(SWIG_As_bool(obj1));
21341 if (SWIG_arg_fail(2)) SWIG_fail;
21342 }
21343 }
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 {
21347 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21348 result = (wxDateTime *) &_result_ref;
21349 }
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxDateTime *arg1 = (wxDateTime *) 0 ;
21364 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21365 int result;
21366 PyObject * obj0 = 0 ;
21367 PyObject * obj1 = 0 ;
21368 char *kwnames[] = {
21369 (char *) "self",(char *) "country", NULL
21370 };
21371
21372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21374 if (SWIG_arg_fail(1)) SWIG_fail;
21375 if (obj1) {
21376 {
21377 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21378 if (SWIG_arg_fail(2)) SWIG_fail;
21379 }
21380 }
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21384
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 {
21389 resultobj = SWIG_From_int((int)(result));
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj;
21399 wxDateTime *arg1 = (wxDateTime *) 0 ;
21400 bool result;
21401 PyObject * obj0 = 0 ;
21402 char *kwnames[] = {
21403 (char *) "self", NULL
21404 };
21405
21406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21408 if (SWIG_arg_fail(1)) SWIG_fail;
21409 {
21410 PyThreadState* __tstate = wxPyBeginAllowThreads();
21411 result = (bool)((wxDateTime const *)arg1)->IsValid();
21412
21413 wxPyEndAllowThreads(__tstate);
21414 if (PyErr_Occurred()) SWIG_fail;
21415 }
21416 {
21417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21418 }
21419 return resultobj;
21420 fail:
21421 return NULL;
21422 }
21423
21424
21425 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21426 PyObject *resultobj;
21427 wxDateTime *arg1 = (wxDateTime *) 0 ;
21428 time_t result;
21429 PyObject * obj0 = 0 ;
21430 char *kwnames[] = {
21431 (char *) "self", NULL
21432 };
21433
21434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21436 if (SWIG_arg_fail(1)) SWIG_fail;
21437 {
21438 PyThreadState* __tstate = wxPyBeginAllowThreads();
21439 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21440
21441 wxPyEndAllowThreads(__tstate);
21442 if (PyErr_Occurred()) SWIG_fail;
21443 }
21444 {
21445 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21446 }
21447 return resultobj;
21448 fail:
21449 return NULL;
21450 }
21451
21452
21453 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21454 PyObject *resultobj;
21455 wxDateTime *arg1 = (wxDateTime *) 0 ;
21456 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21457 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21458 int result;
21459 bool temp2 = false ;
21460 PyObject * obj0 = 0 ;
21461 PyObject * obj1 = 0 ;
21462 char *kwnames[] = {
21463 (char *) "self",(char *) "tz", NULL
21464 };
21465
21466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21468 if (SWIG_arg_fail(1)) SWIG_fail;
21469 if (obj1) {
21470 {
21471 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21472 temp2 = true;
21473 }
21474 }
21475 {
21476 PyThreadState* __tstate = wxPyBeginAllowThreads();
21477 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21478
21479 wxPyEndAllowThreads(__tstate);
21480 if (PyErr_Occurred()) SWIG_fail;
21481 }
21482 {
21483 resultobj = SWIG_From_int((int)(result));
21484 }
21485 {
21486 if (temp2) delete arg2;
21487 }
21488 return resultobj;
21489 fail:
21490 {
21491 if (temp2) delete arg2;
21492 }
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj;
21499 wxDateTime *arg1 = (wxDateTime *) 0 ;
21500 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21501 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21502 wxDateTime::Month result;
21503 bool temp2 = false ;
21504 PyObject * obj0 = 0 ;
21505 PyObject * obj1 = 0 ;
21506 char *kwnames[] = {
21507 (char *) "self",(char *) "tz", NULL
21508 };
21509
21510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21512 if (SWIG_arg_fail(1)) SWIG_fail;
21513 if (obj1) {
21514 {
21515 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21516 temp2 = true;
21517 }
21518 }
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21522
21523 wxPyEndAllowThreads(__tstate);
21524 if (PyErr_Occurred()) SWIG_fail;
21525 }
21526 resultobj = SWIG_From_int((result));
21527 {
21528 if (temp2) delete arg2;
21529 }
21530 return resultobj;
21531 fail:
21532 {
21533 if (temp2) delete arg2;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj;
21541 wxDateTime *arg1 = (wxDateTime *) 0 ;
21542 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21543 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21544 int result;
21545 bool temp2 = false ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self",(char *) "tz", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 if (obj1) {
21556 {
21557 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21558 temp2 = true;
21559 }
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = SWIG_From_int((int)(result));
21570 }
21571 {
21572 if (temp2) delete arg2;
21573 }
21574 return resultobj;
21575 fail:
21576 {
21577 if (temp2) delete arg2;
21578 }
21579 return NULL;
21580 }
21581
21582
21583 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21584 PyObject *resultobj;
21585 wxDateTime *arg1 = (wxDateTime *) 0 ;
21586 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21587 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21588 wxDateTime::WeekDay result;
21589 bool temp2 = false ;
21590 PyObject * obj0 = 0 ;
21591 PyObject * obj1 = 0 ;
21592 char *kwnames[] = {
21593 (char *) "self",(char *) "tz", NULL
21594 };
21595
21596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21598 if (SWIG_arg_fail(1)) SWIG_fail;
21599 if (obj1) {
21600 {
21601 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21602 temp2 = true;
21603 }
21604 }
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21608
21609 wxPyEndAllowThreads(__tstate);
21610 if (PyErr_Occurred()) SWIG_fail;
21611 }
21612 resultobj = SWIG_From_int((result));
21613 {
21614 if (temp2) delete arg2;
21615 }
21616 return resultobj;
21617 fail:
21618 {
21619 if (temp2) delete arg2;
21620 }
21621 return NULL;
21622 }
21623
21624
21625 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj;
21627 wxDateTime *arg1 = (wxDateTime *) 0 ;
21628 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21629 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21630 int result;
21631 bool temp2 = false ;
21632 PyObject * obj0 = 0 ;
21633 PyObject * obj1 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self",(char *) "tz", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 if (obj1) {
21642 {
21643 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21644 temp2 = true;
21645 }
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21650
21651 wxPyEndAllowThreads(__tstate);
21652 if (PyErr_Occurred()) SWIG_fail;
21653 }
21654 {
21655 resultobj = SWIG_From_int((int)(result));
21656 }
21657 {
21658 if (temp2) delete arg2;
21659 }
21660 return resultobj;
21661 fail:
21662 {
21663 if (temp2) delete arg2;
21664 }
21665 return NULL;
21666 }
21667
21668
21669 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21670 PyObject *resultobj;
21671 wxDateTime *arg1 = (wxDateTime *) 0 ;
21672 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21673 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21674 int result;
21675 bool temp2 = false ;
21676 PyObject * obj0 = 0 ;
21677 PyObject * obj1 = 0 ;
21678 char *kwnames[] = {
21679 (char *) "self",(char *) "tz", NULL
21680 };
21681
21682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21684 if (SWIG_arg_fail(1)) SWIG_fail;
21685 if (obj1) {
21686 {
21687 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21688 temp2 = true;
21689 }
21690 }
21691 {
21692 PyThreadState* __tstate = wxPyBeginAllowThreads();
21693 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21694
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 {
21699 resultobj = SWIG_From_int((int)(result));
21700 }
21701 {
21702 if (temp2) delete arg2;
21703 }
21704 return resultobj;
21705 fail:
21706 {
21707 if (temp2) delete arg2;
21708 }
21709 return NULL;
21710 }
21711
21712
21713 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21714 PyObject *resultobj;
21715 wxDateTime *arg1 = (wxDateTime *) 0 ;
21716 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21717 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21718 int result;
21719 bool temp2 = false ;
21720 PyObject * obj0 = 0 ;
21721 PyObject * obj1 = 0 ;
21722 char *kwnames[] = {
21723 (char *) "self",(char *) "tz", NULL
21724 };
21725
21726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21728 if (SWIG_arg_fail(1)) SWIG_fail;
21729 if (obj1) {
21730 {
21731 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21732 temp2 = true;
21733 }
21734 }
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21738
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 resultobj = SWIG_From_int((int)(result));
21744 }
21745 {
21746 if (temp2) delete arg2;
21747 }
21748 return resultobj;
21749 fail:
21750 {
21751 if (temp2) delete arg2;
21752 }
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 wxDateTime *arg1 = (wxDateTime *) 0 ;
21760 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21761 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21762 int result;
21763 bool temp2 = false ;
21764 PyObject * obj0 = 0 ;
21765 PyObject * obj1 = 0 ;
21766 char *kwnames[] = {
21767 (char *) "self",(char *) "tz", NULL
21768 };
21769
21770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21772 if (SWIG_arg_fail(1)) SWIG_fail;
21773 if (obj1) {
21774 {
21775 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21776 temp2 = true;
21777 }
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 {
21787 resultobj = SWIG_From_int((int)(result));
21788 }
21789 {
21790 if (temp2) delete arg2;
21791 }
21792 return resultobj;
21793 fail:
21794 {
21795 if (temp2) delete arg2;
21796 }
21797 return NULL;
21798 }
21799
21800
21801 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21802 PyObject *resultobj;
21803 wxDateTime *arg1 = (wxDateTime *) 0 ;
21804 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21805 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21806 int result;
21807 bool temp2 = false ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 char *kwnames[] = {
21811 (char *) "self",(char *) "tz", NULL
21812 };
21813
21814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 if (obj1) {
21818 {
21819 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21820 temp2 = true;
21821 }
21822 }
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21826
21827 wxPyEndAllowThreads(__tstate);
21828 if (PyErr_Occurred()) SWIG_fail;
21829 }
21830 {
21831 resultobj = SWIG_From_int((int)(result));
21832 }
21833 {
21834 if (temp2) delete arg2;
21835 }
21836 return resultobj;
21837 fail:
21838 {
21839 if (temp2) delete arg2;
21840 }
21841 return NULL;
21842 }
21843
21844
21845 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21846 PyObject *resultobj;
21847 wxDateTime *arg1 = (wxDateTime *) 0 ;
21848 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21849 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21850 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21851 int result;
21852 bool temp3 = false ;
21853 PyObject * obj0 = 0 ;
21854 PyObject * obj1 = 0 ;
21855 PyObject * obj2 = 0 ;
21856 char *kwnames[] = {
21857 (char *) "self",(char *) "flags",(char *) "tz", NULL
21858 };
21859
21860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21862 if (SWIG_arg_fail(1)) SWIG_fail;
21863 if (obj1) {
21864 {
21865 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21866 if (SWIG_arg_fail(2)) SWIG_fail;
21867 }
21868 }
21869 if (obj2) {
21870 {
21871 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21872 temp3 = true;
21873 }
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21878
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 {
21883 resultobj = SWIG_From_int((int)(result));
21884 }
21885 {
21886 if (temp3) delete arg3;
21887 }
21888 return resultobj;
21889 fail:
21890 {
21891 if (temp3) delete arg3;
21892 }
21893 return NULL;
21894 }
21895
21896
21897 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj;
21899 wxDateTime *arg1 = (wxDateTime *) 0 ;
21900 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21901 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21902 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21903 int result;
21904 bool temp3 = false ;
21905 PyObject * obj0 = 0 ;
21906 PyObject * obj1 = 0 ;
21907 PyObject * obj2 = 0 ;
21908 char *kwnames[] = {
21909 (char *) "self",(char *) "flags",(char *) "tz", NULL
21910 };
21911
21912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21914 if (SWIG_arg_fail(1)) SWIG_fail;
21915 if (obj1) {
21916 {
21917 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21918 if (SWIG_arg_fail(2)) SWIG_fail;
21919 }
21920 }
21921 if (obj2) {
21922 {
21923 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21924 temp3 = true;
21925 }
21926 }
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21930
21931 wxPyEndAllowThreads(__tstate);
21932 if (PyErr_Occurred()) SWIG_fail;
21933 }
21934 {
21935 resultobj = SWIG_From_int((int)(result));
21936 }
21937 {
21938 if (temp3) delete arg3;
21939 }
21940 return resultobj;
21941 fail:
21942 {
21943 if (temp3) delete arg3;
21944 }
21945 return NULL;
21946 }
21947
21948
21949 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj;
21951 wxDateTime *arg1 = (wxDateTime *) 0 ;
21952 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21953 bool result;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char *kwnames[] = {
21957 (char *) "self",(char *) "country", NULL
21958 };
21959
21960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21962 if (SWIG_arg_fail(1)) SWIG_fail;
21963 if (obj1) {
21964 {
21965 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21966 if (SWIG_arg_fail(2)) SWIG_fail;
21967 }
21968 }
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21972
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 {
21977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21978 }
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21986 PyObject *resultobj;
21987 wxDateTime *arg1 = (wxDateTime *) 0 ;
21988 wxDateTime *arg2 = 0 ;
21989 bool result;
21990 PyObject * obj0 = 0 ;
21991 PyObject * obj1 = 0 ;
21992 char *kwnames[] = {
21993 (char *) "self",(char *) "datetime", NULL
21994 };
21995
21996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21998 if (SWIG_arg_fail(1)) SWIG_fail;
21999 {
22000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22001 if (SWIG_arg_fail(2)) SWIG_fail;
22002 if (arg2 == NULL) {
22003 SWIG_null_ref("wxDateTime");
22004 }
22005 if (SWIG_arg_fail(2)) SWIG_fail;
22006 }
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22010
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 {
22015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22016 }
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22024 PyObject *resultobj;
22025 wxDateTime *arg1 = (wxDateTime *) 0 ;
22026 wxDateTime *arg2 = 0 ;
22027 bool result;
22028 PyObject * obj0 = 0 ;
22029 PyObject * obj1 = 0 ;
22030 char *kwnames[] = {
22031 (char *) "self",(char *) "datetime", NULL
22032 };
22033
22034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22036 if (SWIG_arg_fail(1)) SWIG_fail;
22037 {
22038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(2)) SWIG_fail;
22040 if (arg2 == NULL) {
22041 SWIG_null_ref("wxDateTime");
22042 }
22043 if (SWIG_arg_fail(2)) SWIG_fail;
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22048
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22054 }
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj;
22063 wxDateTime *arg1 = (wxDateTime *) 0 ;
22064 wxDateTime *arg2 = 0 ;
22065 bool result;
22066 PyObject * obj0 = 0 ;
22067 PyObject * obj1 = 0 ;
22068 char *kwnames[] = {
22069 (char *) "self",(char *) "datetime", NULL
22070 };
22071
22072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22074 if (SWIG_arg_fail(1)) SWIG_fail;
22075 {
22076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22077 if (SWIG_arg_fail(2)) SWIG_fail;
22078 if (arg2 == NULL) {
22079 SWIG_null_ref("wxDateTime");
22080 }
22081 if (SWIG_arg_fail(2)) SWIG_fail;
22082 }
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22086
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj;
22101 wxDateTime *arg1 = (wxDateTime *) 0 ;
22102 wxDateTime *arg2 = 0 ;
22103 wxDateTime *arg3 = 0 ;
22104 bool result;
22105 PyObject * obj0 = 0 ;
22106 PyObject * obj1 = 0 ;
22107 PyObject * obj2 = 0 ;
22108 char *kwnames[] = {
22109 (char *) "self",(char *) "t1",(char *) "t2", NULL
22110 };
22111
22112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22114 if (SWIG_arg_fail(1)) SWIG_fail;
22115 {
22116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(2)) SWIG_fail;
22118 if (arg2 == NULL) {
22119 SWIG_null_ref("wxDateTime");
22120 }
22121 if (SWIG_arg_fail(2)) SWIG_fail;
22122 }
22123 {
22124 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22125 if (SWIG_arg_fail(3)) SWIG_fail;
22126 if (arg3 == NULL) {
22127 SWIG_null_ref("wxDateTime");
22128 }
22129 if (SWIG_arg_fail(3)) SWIG_fail;
22130 }
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22134
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 {
22139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22140 }
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj;
22149 wxDateTime *arg1 = (wxDateTime *) 0 ;
22150 wxDateTime *arg2 = 0 ;
22151 wxDateTime *arg3 = 0 ;
22152 bool result;
22153 PyObject * obj0 = 0 ;
22154 PyObject * obj1 = 0 ;
22155 PyObject * obj2 = 0 ;
22156 char *kwnames[] = {
22157 (char *) "self",(char *) "t1",(char *) "t2", NULL
22158 };
22159
22160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22162 if (SWIG_arg_fail(1)) SWIG_fail;
22163 {
22164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22165 if (SWIG_arg_fail(2)) SWIG_fail;
22166 if (arg2 == NULL) {
22167 SWIG_null_ref("wxDateTime");
22168 }
22169 if (SWIG_arg_fail(2)) SWIG_fail;
22170 }
22171 {
22172 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22173 if (SWIG_arg_fail(3)) SWIG_fail;
22174 if (arg3 == NULL) {
22175 SWIG_null_ref("wxDateTime");
22176 }
22177 if (SWIG_arg_fail(3)) SWIG_fail;
22178 }
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxDateTime *arg1 = (wxDateTime *) 0 ;
22198 wxDateTime *arg2 = 0 ;
22199 bool result;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char *kwnames[] = {
22203 (char *) "self",(char *) "dt", NULL
22204 };
22205
22206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22208 if (SWIG_arg_fail(1)) SWIG_fail;
22209 {
22210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22211 if (SWIG_arg_fail(2)) SWIG_fail;
22212 if (arg2 == NULL) {
22213 SWIG_null_ref("wxDateTime");
22214 }
22215 if (SWIG_arg_fail(2)) SWIG_fail;
22216 }
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22220
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 {
22225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22226 }
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22234 PyObject *resultobj;
22235 wxDateTime *arg1 = (wxDateTime *) 0 ;
22236 wxDateTime *arg2 = 0 ;
22237 bool result;
22238 PyObject * obj0 = 0 ;
22239 PyObject * obj1 = 0 ;
22240 char *kwnames[] = {
22241 (char *) "self",(char *) "dt", NULL
22242 };
22243
22244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22246 if (SWIG_arg_fail(1)) SWIG_fail;
22247 {
22248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(2)) SWIG_fail;
22250 if (arg2 == NULL) {
22251 SWIG_null_ref("wxDateTime");
22252 }
22253 if (SWIG_arg_fail(2)) SWIG_fail;
22254 }
22255 {
22256 PyThreadState* __tstate = wxPyBeginAllowThreads();
22257 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22258
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 {
22263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22264 }
22265 return resultobj;
22266 fail:
22267 return NULL;
22268 }
22269
22270
22271 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22272 PyObject *resultobj;
22273 wxDateTime *arg1 = (wxDateTime *) 0 ;
22274 wxDateTime *arg2 = 0 ;
22275 wxTimeSpan *arg3 = 0 ;
22276 bool result;
22277 PyObject * obj0 = 0 ;
22278 PyObject * obj1 = 0 ;
22279 PyObject * obj2 = 0 ;
22280 char *kwnames[] = {
22281 (char *) "self",(char *) "dt",(char *) "ts", NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22286 if (SWIG_arg_fail(1)) SWIG_fail;
22287 {
22288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 if (arg2 == NULL) {
22291 SWIG_null_ref("wxDateTime");
22292 }
22293 if (SWIG_arg_fail(2)) SWIG_fail;
22294 }
22295 {
22296 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22297 if (SWIG_arg_fail(3)) SWIG_fail;
22298 if (arg3 == NULL) {
22299 SWIG_null_ref("wxTimeSpan");
22300 }
22301 if (SWIG_arg_fail(3)) SWIG_fail;
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 {
22311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22312 }
22313 return resultobj;
22314 fail:
22315 return NULL;
22316 }
22317
22318
22319 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22320 PyObject *resultobj;
22321 wxDateTime *arg1 = (wxDateTime *) 0 ;
22322 wxTimeSpan *arg2 = 0 ;
22323 wxDateTime *result;
22324 PyObject * obj0 = 0 ;
22325 PyObject * obj1 = 0 ;
22326 char *kwnames[] = {
22327 (char *) "self",(char *) "diff", NULL
22328 };
22329
22330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22332 if (SWIG_arg_fail(1)) SWIG_fail;
22333 {
22334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(2)) SWIG_fail;
22336 if (arg2 == NULL) {
22337 SWIG_null_ref("wxTimeSpan");
22338 }
22339 if (SWIG_arg_fail(2)) SWIG_fail;
22340 }
22341 {
22342 PyThreadState* __tstate = wxPyBeginAllowThreads();
22343 {
22344 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22345 result = (wxDateTime *) &_result_ref;
22346 }
22347
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22359 PyObject *resultobj;
22360 wxDateTime *arg1 = (wxDateTime *) 0 ;
22361 wxDateSpan *arg2 = 0 ;
22362 wxDateTime *result;
22363 PyObject * obj0 = 0 ;
22364 PyObject * obj1 = 0 ;
22365 char *kwnames[] = {
22366 (char *) "self",(char *) "diff", NULL
22367 };
22368
22369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22371 if (SWIG_arg_fail(1)) SWIG_fail;
22372 {
22373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(2)) SWIG_fail;
22375 if (arg2 == NULL) {
22376 SWIG_null_ref("wxDateSpan");
22377 }
22378 if (SWIG_arg_fail(2)) SWIG_fail;
22379 }
22380 {
22381 PyThreadState* __tstate = wxPyBeginAllowThreads();
22382 {
22383 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22384 result = (wxDateTime *) &_result_ref;
22385 }
22386
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22391 return resultobj;
22392 fail:
22393 return NULL;
22394 }
22395
22396
22397 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22398 PyObject *resultobj;
22399 wxDateTime *arg1 = (wxDateTime *) 0 ;
22400 wxTimeSpan *arg2 = 0 ;
22401 wxDateTime *result;
22402 PyObject * obj0 = 0 ;
22403 PyObject * obj1 = 0 ;
22404 char *kwnames[] = {
22405 (char *) "self",(char *) "diff", NULL
22406 };
22407
22408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22410 if (SWIG_arg_fail(1)) SWIG_fail;
22411 {
22412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22413 if (SWIG_arg_fail(2)) SWIG_fail;
22414 if (arg2 == NULL) {
22415 SWIG_null_ref("wxTimeSpan");
22416 }
22417 if (SWIG_arg_fail(2)) SWIG_fail;
22418 }
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 {
22422 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22423 result = (wxDateTime *) &_result_ref;
22424 }
22425
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj;
22438 wxDateTime *arg1 = (wxDateTime *) 0 ;
22439 wxDateSpan *arg2 = 0 ;
22440 wxDateTime *result;
22441 PyObject * obj0 = 0 ;
22442 PyObject * obj1 = 0 ;
22443 char *kwnames[] = {
22444 (char *) "self",(char *) "diff", NULL
22445 };
22446
22447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22449 if (SWIG_arg_fail(1)) SWIG_fail;
22450 {
22451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22452 if (SWIG_arg_fail(2)) SWIG_fail;
22453 if (arg2 == NULL) {
22454 SWIG_null_ref("wxDateSpan");
22455 }
22456 if (SWIG_arg_fail(2)) SWIG_fail;
22457 }
22458 {
22459 PyThreadState* __tstate = wxPyBeginAllowThreads();
22460 {
22461 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22462 result = (wxDateTime *) &_result_ref;
22463 }
22464
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22476 PyObject *resultobj;
22477 wxDateTime *arg1 = (wxDateTime *) 0 ;
22478 wxDateTime *arg2 = 0 ;
22479 wxTimeSpan result;
22480 PyObject * obj0 = 0 ;
22481 PyObject * obj1 = 0 ;
22482 char *kwnames[] = {
22483 (char *) "self",(char *) "dt", NULL
22484 };
22485
22486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22488 if (SWIG_arg_fail(1)) SWIG_fail;
22489 {
22490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22491 if (SWIG_arg_fail(2)) SWIG_fail;
22492 if (arg2 == NULL) {
22493 SWIG_null_ref("wxDateTime");
22494 }
22495 if (SWIG_arg_fail(2)) SWIG_fail;
22496 }
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22500
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 {
22505 wxTimeSpan * resultptr;
22506 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22508 }
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22516 PyObject *resultobj;
22517 wxDateTime *arg1 = (wxDateTime *) 0 ;
22518 wxTimeSpan *arg2 = 0 ;
22519 wxDateTime *result;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522
22523 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 if (arg2 == NULL) {
22530 SWIG_null_ref("wxTimeSpan");
22531 }
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 }
22534 {
22535 PyThreadState* __tstate = wxPyBeginAllowThreads();
22536 {
22537 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22538 result = (wxDateTime *) &_result_ref;
22539 }
22540
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22552 PyObject *resultobj;
22553 wxDateTime *arg1 = (wxDateTime *) 0 ;
22554 wxDateSpan *arg2 = 0 ;
22555 wxDateTime *result;
22556 PyObject * obj0 = 0 ;
22557 PyObject * obj1 = 0 ;
22558
22559 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22561 if (SWIG_arg_fail(1)) SWIG_fail;
22562 {
22563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22564 if (SWIG_arg_fail(2)) SWIG_fail;
22565 if (arg2 == NULL) {
22566 SWIG_null_ref("wxDateSpan");
22567 }
22568 if (SWIG_arg_fail(2)) SWIG_fail;
22569 }
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 {
22573 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22574 result = (wxDateTime *) &_result_ref;
22575 }
22576
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22581 return resultobj;
22582 fail:
22583 return NULL;
22584 }
22585
22586
22587 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22588 int argc;
22589 PyObject *argv[3];
22590 int ii;
22591
22592 argc = PyObject_Length(args);
22593 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22594 argv[ii] = PyTuple_GetItem(args,ii);
22595 }
22596 if (argc == 2) {
22597 int _v;
22598 {
22599 void *ptr;
22600 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22601 _v = 0;
22602 PyErr_Clear();
22603 } else {
22604 _v = 1;
22605 }
22606 }
22607 if (_v) {
22608 {
22609 void *ptr = 0;
22610 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22611 _v = 0;
22612 PyErr_Clear();
22613 } else {
22614 _v = (ptr != 0);
22615 }
22616 }
22617 if (_v) {
22618 return _wrap_DateTime___iadd____SWIG_0(self,args);
22619 }
22620 }
22621 }
22622 if (argc == 2) {
22623 int _v;
22624 {
22625 void *ptr;
22626 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22627 _v = 0;
22628 PyErr_Clear();
22629 } else {
22630 _v = 1;
22631 }
22632 }
22633 if (_v) {
22634 {
22635 void *ptr = 0;
22636 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22637 _v = 0;
22638 PyErr_Clear();
22639 } else {
22640 _v = (ptr != 0);
22641 }
22642 }
22643 if (_v) {
22644 return _wrap_DateTime___iadd____SWIG_1(self,args);
22645 }
22646 }
22647 }
22648
22649 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22650 return NULL;
22651 }
22652
22653
22654 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22655 PyObject *resultobj;
22656 wxDateTime *arg1 = (wxDateTime *) 0 ;
22657 wxTimeSpan *arg2 = 0 ;
22658 wxDateTime *result;
22659 PyObject * obj0 = 0 ;
22660 PyObject * obj1 = 0 ;
22661
22662 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22664 if (SWIG_arg_fail(1)) SWIG_fail;
22665 {
22666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22667 if (SWIG_arg_fail(2)) SWIG_fail;
22668 if (arg2 == NULL) {
22669 SWIG_null_ref("wxTimeSpan");
22670 }
22671 if (SWIG_arg_fail(2)) SWIG_fail;
22672 }
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 {
22676 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22677 result = (wxDateTime *) &_result_ref;
22678 }
22679
22680 wxPyEndAllowThreads(__tstate);
22681 if (PyErr_Occurred()) SWIG_fail;
22682 }
22683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22691 PyObject *resultobj;
22692 wxDateTime *arg1 = (wxDateTime *) 0 ;
22693 wxDateSpan *arg2 = 0 ;
22694 wxDateTime *result;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697
22698 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22700 if (SWIG_arg_fail(1)) SWIG_fail;
22701 {
22702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22703 if (SWIG_arg_fail(2)) SWIG_fail;
22704 if (arg2 == NULL) {
22705 SWIG_null_ref("wxDateSpan");
22706 }
22707 if (SWIG_arg_fail(2)) SWIG_fail;
22708 }
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 {
22712 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22713 result = (wxDateTime *) &_result_ref;
22714 }
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22727 int argc;
22728 PyObject *argv[3];
22729 int ii;
22730
22731 argc = PyObject_Length(args);
22732 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22733 argv[ii] = PyTuple_GetItem(args,ii);
22734 }
22735 if (argc == 2) {
22736 int _v;
22737 {
22738 void *ptr;
22739 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22740 _v = 0;
22741 PyErr_Clear();
22742 } else {
22743 _v = 1;
22744 }
22745 }
22746 if (_v) {
22747 {
22748 void *ptr = 0;
22749 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22750 _v = 0;
22751 PyErr_Clear();
22752 } else {
22753 _v = (ptr != 0);
22754 }
22755 }
22756 if (_v) {
22757 return _wrap_DateTime___isub____SWIG_0(self,args);
22758 }
22759 }
22760 }
22761 if (argc == 2) {
22762 int _v;
22763 {
22764 void *ptr;
22765 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22766 _v = 0;
22767 PyErr_Clear();
22768 } else {
22769 _v = 1;
22770 }
22771 }
22772 if (_v) {
22773 {
22774 void *ptr = 0;
22775 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22776 _v = 0;
22777 PyErr_Clear();
22778 } else {
22779 _v = (ptr != 0);
22780 }
22781 }
22782 if (_v) {
22783 return _wrap_DateTime___isub____SWIG_1(self,args);
22784 }
22785 }
22786 }
22787
22788 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22789 return NULL;
22790 }
22791
22792
22793 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22794 PyObject *resultobj;
22795 wxDateTime *arg1 = (wxDateTime *) 0 ;
22796 wxTimeSpan *arg2 = 0 ;
22797 wxDateTime result;
22798 PyObject * obj0 = 0 ;
22799 PyObject * obj1 = 0 ;
22800
22801 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22803 if (SWIG_arg_fail(1)) SWIG_fail;
22804 {
22805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(2)) SWIG_fail;
22807 if (arg2 == NULL) {
22808 SWIG_null_ref("wxTimeSpan");
22809 }
22810 if (SWIG_arg_fail(2)) SWIG_fail;
22811 }
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22815
22816 wxPyEndAllowThreads(__tstate);
22817 if (PyErr_Occurred()) SWIG_fail;
22818 }
22819 {
22820 wxDateTime * resultptr;
22821 resultptr = new wxDateTime((wxDateTime &)(result));
22822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22823 }
22824 return resultobj;
22825 fail:
22826 return NULL;
22827 }
22828
22829
22830 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22831 PyObject *resultobj;
22832 wxDateTime *arg1 = (wxDateTime *) 0 ;
22833 wxDateSpan *arg2 = 0 ;
22834 wxDateTime result;
22835 PyObject * obj0 = 0 ;
22836 PyObject * obj1 = 0 ;
22837
22838 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22840 if (SWIG_arg_fail(1)) SWIG_fail;
22841 {
22842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22843 if (SWIG_arg_fail(2)) SWIG_fail;
22844 if (arg2 == NULL) {
22845 SWIG_null_ref("wxDateSpan");
22846 }
22847 if (SWIG_arg_fail(2)) SWIG_fail;
22848 }
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22852
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 {
22857 wxDateTime * resultptr;
22858 resultptr = new wxDateTime((wxDateTime &)(result));
22859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22860 }
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22868 int argc;
22869 PyObject *argv[3];
22870 int ii;
22871
22872 argc = PyObject_Length(args);
22873 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22874 argv[ii] = PyTuple_GetItem(args,ii);
22875 }
22876 if (argc == 2) {
22877 int _v;
22878 {
22879 void *ptr;
22880 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22881 _v = 0;
22882 PyErr_Clear();
22883 } else {
22884 _v = 1;
22885 }
22886 }
22887 if (_v) {
22888 {
22889 void *ptr = 0;
22890 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22891 _v = 0;
22892 PyErr_Clear();
22893 } else {
22894 _v = (ptr != 0);
22895 }
22896 }
22897 if (_v) {
22898 return _wrap_DateTime___add____SWIG_0(self,args);
22899 }
22900 }
22901 }
22902 if (argc == 2) {
22903 int _v;
22904 {
22905 void *ptr;
22906 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22907 _v = 0;
22908 PyErr_Clear();
22909 } else {
22910 _v = 1;
22911 }
22912 }
22913 if (_v) {
22914 {
22915 void *ptr = 0;
22916 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22917 _v = 0;
22918 PyErr_Clear();
22919 } else {
22920 _v = (ptr != 0);
22921 }
22922 }
22923 if (_v) {
22924 return _wrap_DateTime___add____SWIG_1(self,args);
22925 }
22926 }
22927 }
22928
22929 Py_INCREF(Py_NotImplemented);
22930 return Py_NotImplemented;
22931 }
22932
22933
22934 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22935 PyObject *resultobj;
22936 wxDateTime *arg1 = (wxDateTime *) 0 ;
22937 wxDateTime *arg2 = 0 ;
22938 wxTimeSpan result;
22939 PyObject * obj0 = 0 ;
22940 PyObject * obj1 = 0 ;
22941
22942 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22944 if (SWIG_arg_fail(1)) SWIG_fail;
22945 {
22946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22947 if (SWIG_arg_fail(2)) SWIG_fail;
22948 if (arg2 == NULL) {
22949 SWIG_null_ref("wxDateTime");
22950 }
22951 if (SWIG_arg_fail(2)) SWIG_fail;
22952 }
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22956
22957 wxPyEndAllowThreads(__tstate);
22958 if (PyErr_Occurred()) SWIG_fail;
22959 }
22960 {
22961 wxTimeSpan * resultptr;
22962 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22964 }
22965 return resultobj;
22966 fail:
22967 return NULL;
22968 }
22969
22970
22971 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22972 PyObject *resultobj;
22973 wxDateTime *arg1 = (wxDateTime *) 0 ;
22974 wxTimeSpan *arg2 = 0 ;
22975 wxDateTime result;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978
22979 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22981 if (SWIG_arg_fail(1)) SWIG_fail;
22982 {
22983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22984 if (SWIG_arg_fail(2)) SWIG_fail;
22985 if (arg2 == NULL) {
22986 SWIG_null_ref("wxTimeSpan");
22987 }
22988 if (SWIG_arg_fail(2)) SWIG_fail;
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22993
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 {
22998 wxDateTime * resultptr;
22999 resultptr = new wxDateTime((wxDateTime &)(result));
23000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23001 }
23002 return resultobj;
23003 fail:
23004 return NULL;
23005 }
23006
23007
23008 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23009 PyObject *resultobj;
23010 wxDateTime *arg1 = (wxDateTime *) 0 ;
23011 wxDateSpan *arg2 = 0 ;
23012 wxDateTime result;
23013 PyObject * obj0 = 0 ;
23014 PyObject * obj1 = 0 ;
23015
23016 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23018 if (SWIG_arg_fail(1)) SWIG_fail;
23019 {
23020 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23021 if (SWIG_arg_fail(2)) SWIG_fail;
23022 if (arg2 == NULL) {
23023 SWIG_null_ref("wxDateSpan");
23024 }
23025 if (SWIG_arg_fail(2)) SWIG_fail;
23026 }
23027 {
23028 PyThreadState* __tstate = wxPyBeginAllowThreads();
23029 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23030
23031 wxPyEndAllowThreads(__tstate);
23032 if (PyErr_Occurred()) SWIG_fail;
23033 }
23034 {
23035 wxDateTime * resultptr;
23036 resultptr = new wxDateTime((wxDateTime &)(result));
23037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23038 }
23039 return resultobj;
23040 fail:
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23046 int argc;
23047 PyObject *argv[3];
23048 int ii;
23049
23050 argc = PyObject_Length(args);
23051 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23052 argv[ii] = PyTuple_GetItem(args,ii);
23053 }
23054 if (argc == 2) {
23055 int _v;
23056 {
23057 void *ptr;
23058 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23059 _v = 0;
23060 PyErr_Clear();
23061 } else {
23062 _v = 1;
23063 }
23064 }
23065 if (_v) {
23066 {
23067 void *ptr = 0;
23068 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23069 _v = 0;
23070 PyErr_Clear();
23071 } else {
23072 _v = (ptr != 0);
23073 }
23074 }
23075 if (_v) {
23076 return _wrap_DateTime___sub____SWIG_0(self,args);
23077 }
23078 }
23079 }
23080 if (argc == 2) {
23081 int _v;
23082 {
23083 void *ptr;
23084 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23085 _v = 0;
23086 PyErr_Clear();
23087 } else {
23088 _v = 1;
23089 }
23090 }
23091 if (_v) {
23092 {
23093 void *ptr = 0;
23094 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23095 _v = 0;
23096 PyErr_Clear();
23097 } else {
23098 _v = (ptr != 0);
23099 }
23100 }
23101 if (_v) {
23102 return _wrap_DateTime___sub____SWIG_1(self,args);
23103 }
23104 }
23105 }
23106 if (argc == 2) {
23107 int _v;
23108 {
23109 void *ptr;
23110 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23111 _v = 0;
23112 PyErr_Clear();
23113 } else {
23114 _v = 1;
23115 }
23116 }
23117 if (_v) {
23118 {
23119 void *ptr = 0;
23120 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23121 _v = 0;
23122 PyErr_Clear();
23123 } else {
23124 _v = (ptr != 0);
23125 }
23126 }
23127 if (_v) {
23128 return _wrap_DateTime___sub____SWIG_2(self,args);
23129 }
23130 }
23131 }
23132
23133 Py_INCREF(Py_NotImplemented);
23134 return Py_NotImplemented;
23135 }
23136
23137
23138 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj;
23140 wxDateTime *arg1 = (wxDateTime *) 0 ;
23141 wxDateTime *arg2 = (wxDateTime *) 0 ;
23142 bool result;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 char *kwnames[] = {
23146 (char *) "self",(char *) "other", NULL
23147 };
23148
23149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23151 if (SWIG_arg_fail(1)) SWIG_fail;
23152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23153 if (SWIG_arg_fail(2)) SWIG_fail;
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23157
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 {
23162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23163 }
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 wxDateTime *arg1 = (wxDateTime *) 0 ;
23173 wxDateTime *arg2 = (wxDateTime *) 0 ;
23174 bool result;
23175 PyObject * obj0 = 0 ;
23176 PyObject * obj1 = 0 ;
23177 char *kwnames[] = {
23178 (char *) "self",(char *) "other", NULL
23179 };
23180
23181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23183 if (SWIG_arg_fail(1)) SWIG_fail;
23184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23185 if (SWIG_arg_fail(2)) SWIG_fail;
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23189
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 {
23194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23195 }
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj;
23204 wxDateTime *arg1 = (wxDateTime *) 0 ;
23205 wxDateTime *arg2 = (wxDateTime *) 0 ;
23206 bool result;
23207 PyObject * obj0 = 0 ;
23208 PyObject * obj1 = 0 ;
23209 char *kwnames[] = {
23210 (char *) "self",(char *) "other", NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23215 if (SWIG_arg_fail(1)) SWIG_fail;
23216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23217 if (SWIG_arg_fail(2)) SWIG_fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23221
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 {
23226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23227 }
23228 return resultobj;
23229 fail:
23230 return NULL;
23231 }
23232
23233
23234 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23235 PyObject *resultobj;
23236 wxDateTime *arg1 = (wxDateTime *) 0 ;
23237 wxDateTime *arg2 = (wxDateTime *) 0 ;
23238 bool result;
23239 PyObject * obj0 = 0 ;
23240 PyObject * obj1 = 0 ;
23241 char *kwnames[] = {
23242 (char *) "self",(char *) "other", NULL
23243 };
23244
23245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(1)) SWIG_fail;
23248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23249 if (SWIG_arg_fail(2)) SWIG_fail;
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23253
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 {
23258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23259 }
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj;
23268 wxDateTime *arg1 = (wxDateTime *) 0 ;
23269 wxDateTime *arg2 = (wxDateTime *) 0 ;
23270 bool result;
23271 PyObject * obj0 = 0 ;
23272 PyObject * obj1 = 0 ;
23273 char *kwnames[] = {
23274 (char *) "self",(char *) "other", NULL
23275 };
23276
23277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23279 if (SWIG_arg_fail(1)) SWIG_fail;
23280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23281 if (SWIG_arg_fail(2)) SWIG_fail;
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23285
23286 wxPyEndAllowThreads(__tstate);
23287 if (PyErr_Occurred()) SWIG_fail;
23288 }
23289 {
23290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23291 }
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj;
23300 wxDateTime *arg1 = (wxDateTime *) 0 ;
23301 wxDateTime *arg2 = (wxDateTime *) 0 ;
23302 bool result;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "self",(char *) "other", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(1)) SWIG_fail;
23312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23313 if (SWIG_arg_fail(2)) SWIG_fail;
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 {
23322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23323 }
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxDateTime *arg1 = (wxDateTime *) 0 ;
23333 wxString *arg2 = 0 ;
23334 int result;
23335 bool temp2 = false ;
23336 PyObject * obj0 = 0 ;
23337 PyObject * obj1 = 0 ;
23338 char *kwnames[] = {
23339 (char *) "self",(char *) "date", NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23344 if (SWIG_arg_fail(1)) SWIG_fail;
23345 {
23346 arg2 = wxString_in_helper(obj1);
23347 if (arg2 == NULL) SWIG_fail;
23348 temp2 = true;
23349 }
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23353
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = SWIG_From_int((int)(result));
23359 }
23360 {
23361 if (temp2)
23362 delete arg2;
23363 }
23364 return resultobj;
23365 fail:
23366 {
23367 if (temp2)
23368 delete arg2;
23369 }
23370 return NULL;
23371 }
23372
23373
23374 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj;
23376 wxDateTime *arg1 = (wxDateTime *) 0 ;
23377 wxString *arg2 = 0 ;
23378 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23379 wxString *arg3 = (wxString *) &arg3_defvalue ;
23380 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23381 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23382 int result;
23383 bool temp2 = false ;
23384 bool temp3 = false ;
23385 PyObject * obj0 = 0 ;
23386 PyObject * obj1 = 0 ;
23387 PyObject * obj2 = 0 ;
23388 PyObject * obj3 = 0 ;
23389 char *kwnames[] = {
23390 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23391 };
23392
23393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23395 if (SWIG_arg_fail(1)) SWIG_fail;
23396 {
23397 arg2 = wxString_in_helper(obj1);
23398 if (arg2 == NULL) SWIG_fail;
23399 temp2 = true;
23400 }
23401 if (obj2) {
23402 {
23403 arg3 = wxString_in_helper(obj2);
23404 if (arg3 == NULL) SWIG_fail;
23405 temp3 = true;
23406 }
23407 }
23408 if (obj3) {
23409 {
23410 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23411 if (SWIG_arg_fail(4)) SWIG_fail;
23412 if (arg4 == NULL) {
23413 SWIG_null_ref("wxDateTime");
23414 }
23415 if (SWIG_arg_fail(4)) SWIG_fail;
23416 }
23417 }
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23421
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 {
23426 resultobj = SWIG_From_int((int)(result));
23427 }
23428 {
23429 if (temp2)
23430 delete arg2;
23431 }
23432 {
23433 if (temp3)
23434 delete arg3;
23435 }
23436 return resultobj;
23437 fail:
23438 {
23439 if (temp2)
23440 delete arg2;
23441 }
23442 {
23443 if (temp3)
23444 delete arg3;
23445 }
23446 return NULL;
23447 }
23448
23449
23450 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj;
23452 wxDateTime *arg1 = (wxDateTime *) 0 ;
23453 wxString *arg2 = 0 ;
23454 int result;
23455 bool temp2 = false ;
23456 PyObject * obj0 = 0 ;
23457 PyObject * obj1 = 0 ;
23458 char *kwnames[] = {
23459 (char *) "self",(char *) "datetime", NULL
23460 };
23461
23462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23464 if (SWIG_arg_fail(1)) SWIG_fail;
23465 {
23466 arg2 = wxString_in_helper(obj1);
23467 if (arg2 == NULL) SWIG_fail;
23468 temp2 = true;
23469 }
23470 {
23471 PyThreadState* __tstate = wxPyBeginAllowThreads();
23472 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23473
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 {
23478 resultobj = SWIG_From_int((int)(result));
23479 }
23480 {
23481 if (temp2)
23482 delete arg2;
23483 }
23484 return resultobj;
23485 fail:
23486 {
23487 if (temp2)
23488 delete arg2;
23489 }
23490 return NULL;
23491 }
23492
23493
23494 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23495 PyObject *resultobj;
23496 wxDateTime *arg1 = (wxDateTime *) 0 ;
23497 wxString *arg2 = 0 ;
23498 int result;
23499 bool temp2 = false ;
23500 PyObject * obj0 = 0 ;
23501 PyObject * obj1 = 0 ;
23502 char *kwnames[] = {
23503 (char *) "self",(char *) "date", NULL
23504 };
23505
23506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23508 if (SWIG_arg_fail(1)) SWIG_fail;
23509 {
23510 arg2 = wxString_in_helper(obj1);
23511 if (arg2 == NULL) SWIG_fail;
23512 temp2 = true;
23513 }
23514 {
23515 PyThreadState* __tstate = wxPyBeginAllowThreads();
23516 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23517
23518 wxPyEndAllowThreads(__tstate);
23519 if (PyErr_Occurred()) SWIG_fail;
23520 }
23521 {
23522 resultobj = SWIG_From_int((int)(result));
23523 }
23524 {
23525 if (temp2)
23526 delete arg2;
23527 }
23528 return resultobj;
23529 fail:
23530 {
23531 if (temp2)
23532 delete arg2;
23533 }
23534 return NULL;
23535 }
23536
23537
23538 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23539 PyObject *resultobj;
23540 wxDateTime *arg1 = (wxDateTime *) 0 ;
23541 wxString *arg2 = 0 ;
23542 int result;
23543 bool temp2 = false ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char *kwnames[] = {
23547 (char *) "self",(char *) "time", NULL
23548 };
23549
23550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23552 if (SWIG_arg_fail(1)) SWIG_fail;
23553 {
23554 arg2 = wxString_in_helper(obj1);
23555 if (arg2 == NULL) SWIG_fail;
23556 temp2 = true;
23557 }
23558 {
23559 PyThreadState* __tstate = wxPyBeginAllowThreads();
23560 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23561
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 {
23566 resultobj = SWIG_From_int((int)(result));
23567 }
23568 {
23569 if (temp2)
23570 delete arg2;
23571 }
23572 return resultobj;
23573 fail:
23574 {
23575 if (temp2)
23576 delete arg2;
23577 }
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj;
23584 wxDateTime *arg1 = (wxDateTime *) 0 ;
23585 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23586 wxString *arg2 = (wxString *) &arg2_defvalue ;
23587 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23588 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23589 wxString result;
23590 bool temp2 = false ;
23591 bool temp3 = false ;
23592 PyObject * obj0 = 0 ;
23593 PyObject * obj1 = 0 ;
23594 PyObject * obj2 = 0 ;
23595 char *kwnames[] = {
23596 (char *) "self",(char *) "format",(char *) "tz", NULL
23597 };
23598
23599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23601 if (SWIG_arg_fail(1)) SWIG_fail;
23602 if (obj1) {
23603 {
23604 arg2 = wxString_in_helper(obj1);
23605 if (arg2 == NULL) SWIG_fail;
23606 temp2 = true;
23607 }
23608 }
23609 if (obj2) {
23610 {
23611 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23612 temp3 = true;
23613 }
23614 }
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 #if wxUSE_UNICODE
23624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23625 #else
23626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23627 #endif
23628 }
23629 {
23630 if (temp2)
23631 delete arg2;
23632 }
23633 {
23634 if (temp3) delete arg3;
23635 }
23636 return resultobj;
23637 fail:
23638 {
23639 if (temp2)
23640 delete arg2;
23641 }
23642 {
23643 if (temp3) delete arg3;
23644 }
23645 return NULL;
23646 }
23647
23648
23649 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj;
23651 wxDateTime *arg1 = (wxDateTime *) 0 ;
23652 wxString result;
23653 PyObject * obj0 = 0 ;
23654 char *kwnames[] = {
23655 (char *) "self", NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23660 if (SWIG_arg_fail(1)) SWIG_fail;
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = ((wxDateTime const *)arg1)->FormatDate();
23664
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 #if wxUSE_UNICODE
23670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23671 #else
23672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23673 #endif
23674 }
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23682 PyObject *resultobj;
23683 wxDateTime *arg1 = (wxDateTime *) 0 ;
23684 wxString result;
23685 PyObject * obj0 = 0 ;
23686 char *kwnames[] = {
23687 (char *) "self", NULL
23688 };
23689
23690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23692 if (SWIG_arg_fail(1)) SWIG_fail;
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = ((wxDateTime const *)arg1)->FormatTime();
23696
23697 wxPyEndAllowThreads(__tstate);
23698 if (PyErr_Occurred()) SWIG_fail;
23699 }
23700 {
23701 #if wxUSE_UNICODE
23702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23703 #else
23704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23705 #endif
23706 }
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23714 PyObject *resultobj;
23715 wxDateTime *arg1 = (wxDateTime *) 0 ;
23716 wxString result;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "self", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 result = ((wxDateTime const *)arg1)->FormatISODate();
23728
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 {
23733 #if wxUSE_UNICODE
23734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23735 #else
23736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23737 #endif
23738 }
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj;
23747 wxDateTime *arg1 = (wxDateTime *) 0 ;
23748 wxString result;
23749 PyObject * obj0 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "self", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 {
23758 PyThreadState* __tstate = wxPyBeginAllowThreads();
23759 result = ((wxDateTime const *)arg1)->FormatISOTime();
23760
23761 wxPyEndAllowThreads(__tstate);
23762 if (PyErr_Occurred()) SWIG_fail;
23763 }
23764 {
23765 #if wxUSE_UNICODE
23766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23767 #else
23768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23769 #endif
23770 }
23771 return resultobj;
23772 fail:
23773 return NULL;
23774 }
23775
23776
23777 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23778 PyObject *obj;
23779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23780 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23781 Py_INCREF(obj);
23782 return Py_BuildValue((char *)"");
23783 }
23784 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj;
23786 long arg1 ;
23787 wxTimeSpan result;
23788 PyObject * obj0 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "sec", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23794 {
23795 arg1 = (long)(SWIG_As_long(obj0));
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 }
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = wxTimeSpan::Seconds(arg1);
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 wxTimeSpan * resultptr;
23807 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23809 }
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23817 PyObject *resultobj;
23818 wxTimeSpan result;
23819 char *kwnames[] = {
23820 NULL
23821 };
23822
23823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = wxTimeSpan::Second();
23827
23828 wxPyEndAllowThreads(__tstate);
23829 if (PyErr_Occurred()) SWIG_fail;
23830 }
23831 {
23832 wxTimeSpan * resultptr;
23833 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23835 }
23836 return resultobj;
23837 fail:
23838 return NULL;
23839 }
23840
23841
23842 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23843 PyObject *resultobj;
23844 long arg1 ;
23845 wxTimeSpan result;
23846 PyObject * obj0 = 0 ;
23847 char *kwnames[] = {
23848 (char *) "min", NULL
23849 };
23850
23851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23852 {
23853 arg1 = (long)(SWIG_As_long(obj0));
23854 if (SWIG_arg_fail(1)) SWIG_fail;
23855 }
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = wxTimeSpan::Minutes(arg1);
23859
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 {
23864 wxTimeSpan * resultptr;
23865 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23867 }
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj;
23876 wxTimeSpan result;
23877 char *kwnames[] = {
23878 NULL
23879 };
23880
23881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = wxTimeSpan::Minute();
23885
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 {
23890 wxTimeSpan * resultptr;
23891 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23893 }
23894 return resultobj;
23895 fail:
23896 return NULL;
23897 }
23898
23899
23900 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23901 PyObject *resultobj;
23902 long arg1 ;
23903 wxTimeSpan result;
23904 PyObject * obj0 = 0 ;
23905 char *kwnames[] = {
23906 (char *) "hours", NULL
23907 };
23908
23909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23910 {
23911 arg1 = (long)(SWIG_As_long(obj0));
23912 if (SWIG_arg_fail(1)) SWIG_fail;
23913 }
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = wxTimeSpan::Hours(arg1);
23917
23918 wxPyEndAllowThreads(__tstate);
23919 if (PyErr_Occurred()) SWIG_fail;
23920 }
23921 {
23922 wxTimeSpan * resultptr;
23923 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23925 }
23926 return resultobj;
23927 fail:
23928 return NULL;
23929 }
23930
23931
23932 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj;
23934 wxTimeSpan result;
23935 char *kwnames[] = {
23936 NULL
23937 };
23938
23939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 result = wxTimeSpan::Hour();
23943
23944 wxPyEndAllowThreads(__tstate);
23945 if (PyErr_Occurred()) SWIG_fail;
23946 }
23947 {
23948 wxTimeSpan * resultptr;
23949 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23951 }
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj;
23960 long arg1 ;
23961 wxTimeSpan result;
23962 PyObject * obj0 = 0 ;
23963 char *kwnames[] = {
23964 (char *) "days", NULL
23965 };
23966
23967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23968 {
23969 arg1 = (long)(SWIG_As_long(obj0));
23970 if (SWIG_arg_fail(1)) SWIG_fail;
23971 }
23972 {
23973 PyThreadState* __tstate = wxPyBeginAllowThreads();
23974 result = wxTimeSpan::Days(arg1);
23975
23976 wxPyEndAllowThreads(__tstate);
23977 if (PyErr_Occurred()) SWIG_fail;
23978 }
23979 {
23980 wxTimeSpan * resultptr;
23981 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23983 }
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23991 PyObject *resultobj;
23992 wxTimeSpan result;
23993 char *kwnames[] = {
23994 NULL
23995 };
23996
23997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 result = wxTimeSpan::Day();
24001
24002 wxPyEndAllowThreads(__tstate);
24003 if (PyErr_Occurred()) SWIG_fail;
24004 }
24005 {
24006 wxTimeSpan * resultptr;
24007 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24009 }
24010 return resultobj;
24011 fail:
24012 return NULL;
24013 }
24014
24015
24016 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj;
24018 long arg1 ;
24019 wxTimeSpan result;
24020 PyObject * obj0 = 0 ;
24021 char *kwnames[] = {
24022 (char *) "days", NULL
24023 };
24024
24025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24026 {
24027 arg1 = (long)(SWIG_As_long(obj0));
24028 if (SWIG_arg_fail(1)) SWIG_fail;
24029 }
24030 {
24031 PyThreadState* __tstate = wxPyBeginAllowThreads();
24032 result = wxTimeSpan::Weeks(arg1);
24033
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 {
24038 wxTimeSpan * resultptr;
24039 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24041 }
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxTimeSpan result;
24051 char *kwnames[] = {
24052 NULL
24053 };
24054
24055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24056 {
24057 PyThreadState* __tstate = wxPyBeginAllowThreads();
24058 result = wxTimeSpan::Week();
24059
24060 wxPyEndAllowThreads(__tstate);
24061 if (PyErr_Occurred()) SWIG_fail;
24062 }
24063 {
24064 wxTimeSpan * resultptr;
24065 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24067 }
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24075 PyObject *resultobj;
24076 long arg1 = (long) 0 ;
24077 long arg2 = (long) 0 ;
24078 long arg3 = (long) 0 ;
24079 long arg4 = (long) 0 ;
24080 wxTimeSpan *result;
24081 PyObject * obj0 = 0 ;
24082 PyObject * obj1 = 0 ;
24083 PyObject * obj2 = 0 ;
24084 PyObject * obj3 = 0 ;
24085 char *kwnames[] = {
24086 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24087 };
24088
24089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24090 if (obj0) {
24091 {
24092 arg1 = (long)(SWIG_As_long(obj0));
24093 if (SWIG_arg_fail(1)) SWIG_fail;
24094 }
24095 }
24096 if (obj1) {
24097 {
24098 arg2 = (long)(SWIG_As_long(obj1));
24099 if (SWIG_arg_fail(2)) SWIG_fail;
24100 }
24101 }
24102 if (obj2) {
24103 {
24104 arg3 = (long)(SWIG_As_long(obj2));
24105 if (SWIG_arg_fail(3)) SWIG_fail;
24106 }
24107 }
24108 if (obj3) {
24109 {
24110 arg4 = (long)(SWIG_As_long(obj3));
24111 if (SWIG_arg_fail(4)) SWIG_fail;
24112 }
24113 }
24114 {
24115 PyThreadState* __tstate = wxPyBeginAllowThreads();
24116 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24117
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj;
24130 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24131 PyObject * obj0 = 0 ;
24132 char *kwnames[] = {
24133 (char *) "self", NULL
24134 };
24135
24136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24138 if (SWIG_arg_fail(1)) SWIG_fail;
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 delete arg1;
24142
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 Py_INCREF(Py_None); resultobj = Py_None;
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj;
24155 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24156 wxTimeSpan *arg2 = 0 ;
24157 wxTimeSpan *result;
24158 PyObject * obj0 = 0 ;
24159 PyObject * obj1 = 0 ;
24160 char *kwnames[] = {
24161 (char *) "self",(char *) "diff", NULL
24162 };
24163
24164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24166 if (SWIG_arg_fail(1)) SWIG_fail;
24167 {
24168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(2)) SWIG_fail;
24170 if (arg2 == NULL) {
24171 SWIG_null_ref("wxTimeSpan");
24172 }
24173 if (SWIG_arg_fail(2)) SWIG_fail;
24174 }
24175 {
24176 PyThreadState* __tstate = wxPyBeginAllowThreads();
24177 {
24178 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24179 result = (wxTimeSpan *) &_result_ref;
24180 }
24181
24182 wxPyEndAllowThreads(__tstate);
24183 if (PyErr_Occurred()) SWIG_fail;
24184 }
24185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24186 return resultobj;
24187 fail:
24188 return NULL;
24189 }
24190
24191
24192 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24193 PyObject *resultobj;
24194 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24195 wxTimeSpan *arg2 = 0 ;
24196 wxTimeSpan *result;
24197 PyObject * obj0 = 0 ;
24198 PyObject * obj1 = 0 ;
24199 char *kwnames[] = {
24200 (char *) "self",(char *) "diff", NULL
24201 };
24202
24203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24205 if (SWIG_arg_fail(1)) SWIG_fail;
24206 {
24207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24208 if (SWIG_arg_fail(2)) SWIG_fail;
24209 if (arg2 == NULL) {
24210 SWIG_null_ref("wxTimeSpan");
24211 }
24212 if (SWIG_arg_fail(2)) SWIG_fail;
24213 }
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 {
24217 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24218 result = (wxTimeSpan *) &_result_ref;
24219 }
24220
24221 wxPyEndAllowThreads(__tstate);
24222 if (PyErr_Occurred()) SWIG_fail;
24223 }
24224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj;
24233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24234 int arg2 ;
24235 wxTimeSpan *result;
24236 PyObject * obj0 = 0 ;
24237 PyObject * obj1 = 0 ;
24238 char *kwnames[] = {
24239 (char *) "self",(char *) "n", NULL
24240 };
24241
24242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24244 if (SWIG_arg_fail(1)) SWIG_fail;
24245 {
24246 arg2 = (int)(SWIG_As_int(obj1));
24247 if (SWIG_arg_fail(2)) SWIG_fail;
24248 }
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 {
24252 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24253 result = (wxTimeSpan *) &_result_ref;
24254 }
24255
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24267 PyObject *resultobj;
24268 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24269 wxTimeSpan *result;
24270 PyObject * obj0 = 0 ;
24271 char *kwnames[] = {
24272 (char *) "self", NULL
24273 };
24274
24275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(1)) SWIG_fail;
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 {
24281 wxTimeSpan &_result_ref = (arg1)->Neg();
24282 result = (wxTimeSpan *) &_result_ref;
24283 }
24284
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24298 wxTimeSpan result;
24299 PyObject * obj0 = 0 ;
24300 char *kwnames[] = {
24301 (char *) "self", NULL
24302 };
24303
24304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24306 if (SWIG_arg_fail(1)) SWIG_fail;
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 result = ((wxTimeSpan const *)arg1)->Abs();
24310
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 {
24315 wxTimeSpan * resultptr;
24316 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24318 }
24319 return resultobj;
24320 fail:
24321 return NULL;
24322 }
24323
24324
24325 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24326 PyObject *resultobj;
24327 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24328 wxTimeSpan *arg2 = 0 ;
24329 wxTimeSpan *result;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 char *kwnames[] = {
24333 (char *) "self",(char *) "diff", NULL
24334 };
24335
24336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24338 if (SWIG_arg_fail(1)) SWIG_fail;
24339 {
24340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24341 if (SWIG_arg_fail(2)) SWIG_fail;
24342 if (arg2 == NULL) {
24343 SWIG_null_ref("wxTimeSpan");
24344 }
24345 if (SWIG_arg_fail(2)) SWIG_fail;
24346 }
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 {
24350 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24351 result = (wxTimeSpan *) &_result_ref;
24352 }
24353
24354 wxPyEndAllowThreads(__tstate);
24355 if (PyErr_Occurred()) SWIG_fail;
24356 }
24357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj;
24366 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24367 wxTimeSpan *arg2 = 0 ;
24368 wxTimeSpan *result;
24369 PyObject * obj0 = 0 ;
24370 PyObject * obj1 = 0 ;
24371 char *kwnames[] = {
24372 (char *) "self",(char *) "diff", NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24377 if (SWIG_arg_fail(1)) SWIG_fail;
24378 {
24379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24380 if (SWIG_arg_fail(2)) SWIG_fail;
24381 if (arg2 == NULL) {
24382 SWIG_null_ref("wxTimeSpan");
24383 }
24384 if (SWIG_arg_fail(2)) SWIG_fail;
24385 }
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 {
24389 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24390 result = (wxTimeSpan *) &_result_ref;
24391 }
24392
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24404 PyObject *resultobj;
24405 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24406 int arg2 ;
24407 wxTimeSpan *result;
24408 PyObject * obj0 = 0 ;
24409 PyObject * obj1 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "self",(char *) "n", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 {
24418 arg2 = (int)(SWIG_As_int(obj1));
24419 if (SWIG_arg_fail(2)) SWIG_fail;
24420 }
24421 {
24422 PyThreadState* __tstate = wxPyBeginAllowThreads();
24423 {
24424 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24425 result = (wxTimeSpan *) &_result_ref;
24426 }
24427
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj;
24440 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24441 wxTimeSpan *result;
24442 PyObject * obj0 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 {
24453 wxTimeSpan &_result_ref = (arg1)->operator -();
24454 result = (wxTimeSpan *) &_result_ref;
24455 }
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj;
24469 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24470 wxTimeSpan *arg2 = 0 ;
24471 wxTimeSpan result;
24472 PyObject * obj0 = 0 ;
24473 PyObject * obj1 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self",(char *) "other", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(2)) SWIG_fail;
24484 if (arg2 == NULL) {
24485 SWIG_null_ref("wxTimeSpan");
24486 }
24487 if (SWIG_arg_fail(2)) SWIG_fail;
24488 }
24489 {
24490 PyThreadState* __tstate = wxPyBeginAllowThreads();
24491 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24492
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 {
24497 wxTimeSpan * resultptr;
24498 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24500 }
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24508 PyObject *resultobj;
24509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24510 wxTimeSpan *arg2 = 0 ;
24511 wxTimeSpan result;
24512 PyObject * obj0 = 0 ;
24513 PyObject * obj1 = 0 ;
24514 char *kwnames[] = {
24515 (char *) "self",(char *) "other", NULL
24516 };
24517
24518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24520 if (SWIG_arg_fail(1)) SWIG_fail;
24521 {
24522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24523 if (SWIG_arg_fail(2)) SWIG_fail;
24524 if (arg2 == NULL) {
24525 SWIG_null_ref("wxTimeSpan");
24526 }
24527 if (SWIG_arg_fail(2)) SWIG_fail;
24528 }
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 wxTimeSpan * resultptr;
24538 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24540 }
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj;
24549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24550 int arg2 ;
24551 wxTimeSpan result;
24552 PyObject * obj0 = 0 ;
24553 PyObject * obj1 = 0 ;
24554 char *kwnames[] = {
24555 (char *) "self",(char *) "n", NULL
24556 };
24557
24558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24560 if (SWIG_arg_fail(1)) SWIG_fail;
24561 {
24562 arg2 = (int)(SWIG_As_int(obj1));
24563 if (SWIG_arg_fail(2)) SWIG_fail;
24564 }
24565 {
24566 PyThreadState* __tstate = wxPyBeginAllowThreads();
24567 result = wxTimeSpan___mul__(arg1,arg2);
24568
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 {
24573 wxTimeSpan * resultptr;
24574 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24576 }
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj;
24585 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24586 int arg2 ;
24587 wxTimeSpan result;
24588 PyObject * obj0 = 0 ;
24589 PyObject * obj1 = 0 ;
24590 char *kwnames[] = {
24591 (char *) "self",(char *) "n", NULL
24592 };
24593
24594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(1)) SWIG_fail;
24597 {
24598 arg2 = (int)(SWIG_As_int(obj1));
24599 if (SWIG_arg_fail(2)) SWIG_fail;
24600 }
24601 {
24602 PyThreadState* __tstate = wxPyBeginAllowThreads();
24603 result = wxTimeSpan___rmul__(arg1,arg2);
24604
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 {
24609 wxTimeSpan * resultptr;
24610 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj;
24621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24622 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24623 bool result;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char *kwnames[] = {
24627 (char *) "self",(char *) "other", NULL
24628 };
24629
24630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24632 if (SWIG_arg_fail(1)) SWIG_fail;
24633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24634 if (SWIG_arg_fail(2)) SWIG_fail;
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24638
24639 wxPyEndAllowThreads(__tstate);
24640 if (PyErr_Occurred()) SWIG_fail;
24641 }
24642 {
24643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24644 }
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24655 bool result;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 char *kwnames[] = {
24659 (char *) "self",(char *) "other", NULL
24660 };
24661
24662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24664 if (SWIG_arg_fail(1)) SWIG_fail;
24665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(2)) SWIG_fail;
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 {
24675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24676 }
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24686 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24687 bool result;
24688 PyObject * obj0 = 0 ;
24689 PyObject * obj1 = 0 ;
24690 char *kwnames[] = {
24691 (char *) "self",(char *) "other", NULL
24692 };
24693
24694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24696 if (SWIG_arg_fail(1)) SWIG_fail;
24697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24698 if (SWIG_arg_fail(2)) SWIG_fail;
24699 {
24700 PyThreadState* __tstate = wxPyBeginAllowThreads();
24701 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24702
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 {
24707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24708 }
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24718 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "other", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24730 if (SWIG_arg_fail(2)) SWIG_fail;
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24734
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 {
24739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24740 }
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj;
24749 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24750 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24751 bool result;
24752 PyObject * obj0 = 0 ;
24753 PyObject * obj1 = 0 ;
24754 char *kwnames[] = {
24755 (char *) "self",(char *) "other", NULL
24756 };
24757
24758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24760 if (SWIG_arg_fail(1)) SWIG_fail;
24761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(2)) SWIG_fail;
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 {
24771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24772 }
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24782 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24783 bool result;
24784 PyObject * obj0 = 0 ;
24785 PyObject * obj1 = 0 ;
24786 char *kwnames[] = {
24787 (char *) "self",(char *) "other", NULL
24788 };
24789
24790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24792 if (SWIG_arg_fail(1)) SWIG_fail;
24793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24794 if (SWIG_arg_fail(2)) SWIG_fail;
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24798
24799 wxPyEndAllowThreads(__tstate);
24800 if (PyErr_Occurred()) SWIG_fail;
24801 }
24802 {
24803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24804 }
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj;
24813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24814 bool result;
24815 PyObject * obj0 = 0 ;
24816 char *kwnames[] = {
24817 (char *) "self", NULL
24818 };
24819
24820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(1)) SWIG_fail;
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24832 }
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24842 bool result;
24843 PyObject * obj0 = 0 ;
24844 char *kwnames[] = {
24845 (char *) "self", NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24850 if (SWIG_arg_fail(1)) SWIG_fail;
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24854
24855 wxPyEndAllowThreads(__tstate);
24856 if (PyErr_Occurred()) SWIG_fail;
24857 }
24858 {
24859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24860 }
24861 return resultobj;
24862 fail:
24863 return NULL;
24864 }
24865
24866
24867 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24868 PyObject *resultobj;
24869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24870 bool result;
24871 PyObject * obj0 = 0 ;
24872 char *kwnames[] = {
24873 (char *) "self", NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24878 if (SWIG_arg_fail(1)) SWIG_fail;
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24882
24883 wxPyEndAllowThreads(__tstate);
24884 if (PyErr_Occurred()) SWIG_fail;
24885 }
24886 {
24887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24888 }
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24896 PyObject *resultobj;
24897 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24898 wxTimeSpan *arg2 = 0 ;
24899 bool result;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 char *kwnames[] = {
24903 (char *) "self",(char *) "ts", NULL
24904 };
24905
24906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24908 if (SWIG_arg_fail(1)) SWIG_fail;
24909 {
24910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(2)) SWIG_fail;
24912 if (arg2 == NULL) {
24913 SWIG_null_ref("wxTimeSpan");
24914 }
24915 if (SWIG_arg_fail(2)) SWIG_fail;
24916 }
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24920
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 {
24925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24926 }
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24934 PyObject *resultobj;
24935 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24936 wxTimeSpan *arg2 = 0 ;
24937 bool result;
24938 PyObject * obj0 = 0 ;
24939 PyObject * obj1 = 0 ;
24940 char *kwnames[] = {
24941 (char *) "self",(char *) "ts", NULL
24942 };
24943
24944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24946 if (SWIG_arg_fail(1)) SWIG_fail;
24947 {
24948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24949 if (SWIG_arg_fail(2)) SWIG_fail;
24950 if (arg2 == NULL) {
24951 SWIG_null_ref("wxTimeSpan");
24952 }
24953 if (SWIG_arg_fail(2)) SWIG_fail;
24954 }
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24958
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 {
24963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24964 }
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24972 PyObject *resultobj;
24973 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24974 wxTimeSpan *arg2 = 0 ;
24975 bool result;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 char *kwnames[] = {
24979 (char *) "self",(char *) "t", NULL
24980 };
24981
24982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(1)) SWIG_fail;
24985 {
24986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24987 if (SWIG_arg_fail(2)) SWIG_fail;
24988 if (arg2 == NULL) {
24989 SWIG_null_ref("wxTimeSpan");
24990 }
24991 if (SWIG_arg_fail(2)) SWIG_fail;
24992 }
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24996
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 {
25001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25002 }
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25010 PyObject *resultobj;
25011 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25012 int result;
25013 PyObject * obj0 = 0 ;
25014 char *kwnames[] = {
25015 (char *) "self", NULL
25016 };
25017
25018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25020 if (SWIG_arg_fail(1)) SWIG_fail;
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = SWIG_From_int((int)(result));
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25038 PyObject *resultobj;
25039 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25040 int result;
25041 PyObject * obj0 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25052
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 {
25057 resultobj = SWIG_From_int((int)(result));
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25068 int result;
25069 PyObject * obj0 = 0 ;
25070 char *kwnames[] = {
25071 (char *) "self", NULL
25072 };
25073
25074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25076 if (SWIG_arg_fail(1)) SWIG_fail;
25077 {
25078 PyThreadState* __tstate = wxPyBeginAllowThreads();
25079 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25080
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 resultobj = SWIG_From_int((int)(result));
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25094 PyObject *resultobj;
25095 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25096 int result;
25097 PyObject * obj0 = 0 ;
25098 char *kwnames[] = {
25099 (char *) "self", NULL
25100 };
25101
25102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25104 if (SWIG_arg_fail(1)) SWIG_fail;
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25108
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 {
25113 resultobj = SWIG_From_int((int)(result));
25114 }
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25122 PyObject *resultobj;
25123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25124 wxLongLong result;
25125 PyObject * obj0 = 0 ;
25126 char *kwnames[] = {
25127 (char *) "self", NULL
25128 };
25129
25130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25132 if (SWIG_arg_fail(1)) SWIG_fail;
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25136
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 {
25141 PyObject *hi, *lo, *shifter, *shifted;
25142 hi = PyLong_FromLong( (&result)->GetHi() );
25143 lo = PyLong_FromLong( (&result)->GetLo() );
25144 shifter = PyLong_FromLong(32);
25145 shifted = PyNumber_Lshift(hi, shifter);
25146 resultobj = PyNumber_Or(shifted, lo);
25147 Py_DECREF(hi);
25148 Py_DECREF(lo);
25149 Py_DECREF(shifter);
25150 Py_DECREF(shifted);
25151 }
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj;
25160 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25161 wxLongLong result;
25162 PyObject * obj0 = 0 ;
25163 char *kwnames[] = {
25164 (char *) "self", NULL
25165 };
25166
25167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25169 if (SWIG_arg_fail(1)) SWIG_fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 {
25178 PyObject *hi, *lo, *shifter, *shifted;
25179 hi = PyLong_FromLong( (&result)->GetHi() );
25180 lo = PyLong_FromLong( (&result)->GetLo() );
25181 shifter = PyLong_FromLong(32);
25182 shifted = PyNumber_Lshift(hi, shifter);
25183 resultobj = PyNumber_Or(shifted, lo);
25184 Py_DECREF(hi);
25185 Py_DECREF(lo);
25186 Py_DECREF(shifter);
25187 Py_DECREF(shifted);
25188 }
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25198 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25199 wxString *arg2 = (wxString *) &arg2_defvalue ;
25200 wxString result;
25201 bool temp2 = false ;
25202 PyObject * obj0 = 0 ;
25203 PyObject * obj1 = 0 ;
25204 char *kwnames[] = {
25205 (char *) "self",(char *) "format", NULL
25206 };
25207
25208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25210 if (SWIG_arg_fail(1)) SWIG_fail;
25211 if (obj1) {
25212 {
25213 arg2 = wxString_in_helper(obj1);
25214 if (arg2 == NULL) SWIG_fail;
25215 temp2 = true;
25216 }
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 {
25226 #if wxUSE_UNICODE
25227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25228 #else
25229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25230 #endif
25231 }
25232 {
25233 if (temp2)
25234 delete arg2;
25235 }
25236 return resultobj;
25237 fail:
25238 {
25239 if (temp2)
25240 delete arg2;
25241 }
25242 return NULL;
25243 }
25244
25245
25246 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25247 PyObject *obj;
25248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25249 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25250 Py_INCREF(obj);
25251 return Py_BuildValue((char *)"");
25252 }
25253 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj;
25255 int arg1 = (int) 0 ;
25256 int arg2 = (int) 0 ;
25257 int arg3 = (int) 0 ;
25258 int arg4 = (int) 0 ;
25259 wxDateSpan *result;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 PyObject * obj2 = 0 ;
25263 PyObject * obj3 = 0 ;
25264 char *kwnames[] = {
25265 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25266 };
25267
25268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25269 if (obj0) {
25270 {
25271 arg1 = (int)(SWIG_As_int(obj0));
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 }
25274 }
25275 if (obj1) {
25276 {
25277 arg2 = (int)(SWIG_As_int(obj1));
25278 if (SWIG_arg_fail(2)) SWIG_fail;
25279 }
25280 }
25281 if (obj2) {
25282 {
25283 arg3 = (int)(SWIG_As_int(obj2));
25284 if (SWIG_arg_fail(3)) SWIG_fail;
25285 }
25286 }
25287 if (obj3) {
25288 {
25289 arg4 = (int)(SWIG_As_int(obj3));
25290 if (SWIG_arg_fail(4)) SWIG_fail;
25291 }
25292 }
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25296
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25308 PyObject *resultobj;
25309 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25310 PyObject * obj0 = 0 ;
25311 char *kwnames[] = {
25312 (char *) "self", NULL
25313 };
25314
25315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25317 if (SWIG_arg_fail(1)) SWIG_fail;
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 delete arg1;
25321
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 Py_INCREF(Py_None); resultobj = Py_None;
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj;
25334 int arg1 ;
25335 wxDateSpan result;
25336 PyObject * obj0 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "days", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25342 {
25343 arg1 = (int)(SWIG_As_int(obj0));
25344 if (SWIG_arg_fail(1)) SWIG_fail;
25345 }
25346 {
25347 PyThreadState* __tstate = wxPyBeginAllowThreads();
25348 result = wxDateSpan::Days(arg1);
25349
25350 wxPyEndAllowThreads(__tstate);
25351 if (PyErr_Occurred()) SWIG_fail;
25352 }
25353 {
25354 wxDateSpan * resultptr;
25355 resultptr = new wxDateSpan((wxDateSpan &)(result));
25356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25357 }
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 wxDateSpan result;
25367 char *kwnames[] = {
25368 NULL
25369 };
25370
25371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25372 {
25373 PyThreadState* __tstate = wxPyBeginAllowThreads();
25374 result = wxDateSpan::Day();
25375
25376 wxPyEndAllowThreads(__tstate);
25377 if (PyErr_Occurred()) SWIG_fail;
25378 }
25379 {
25380 wxDateSpan * resultptr;
25381 resultptr = new wxDateSpan((wxDateSpan &)(result));
25382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25383 }
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25391 PyObject *resultobj;
25392 int arg1 ;
25393 wxDateSpan result;
25394 PyObject * obj0 = 0 ;
25395 char *kwnames[] = {
25396 (char *) "weeks", NULL
25397 };
25398
25399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25400 {
25401 arg1 = (int)(SWIG_As_int(obj0));
25402 if (SWIG_arg_fail(1)) SWIG_fail;
25403 }
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 result = wxDateSpan::Weeks(arg1);
25407
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 {
25412 wxDateSpan * resultptr;
25413 resultptr = new wxDateSpan((wxDateSpan &)(result));
25414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 wxDateSpan result;
25425 char *kwnames[] = {
25426 NULL
25427 };
25428
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 result = wxDateSpan::Week();
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 {
25438 wxDateSpan * resultptr;
25439 resultptr = new wxDateSpan((wxDateSpan &)(result));
25440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25441 }
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj;
25450 int arg1 ;
25451 wxDateSpan result;
25452 PyObject * obj0 = 0 ;
25453 char *kwnames[] = {
25454 (char *) "mon", NULL
25455 };
25456
25457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25458 {
25459 arg1 = (int)(SWIG_As_int(obj0));
25460 if (SWIG_arg_fail(1)) SWIG_fail;
25461 }
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 result = wxDateSpan::Months(arg1);
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 {
25470 wxDateSpan * resultptr;
25471 resultptr = new wxDateSpan((wxDateSpan &)(result));
25472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj;
25482 wxDateSpan result;
25483 char *kwnames[] = {
25484 NULL
25485 };
25486
25487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 result = wxDateSpan::Month();
25491
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 {
25496 wxDateSpan * resultptr;
25497 resultptr = new wxDateSpan((wxDateSpan &)(result));
25498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25499 }
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25507 PyObject *resultobj;
25508 int arg1 ;
25509 wxDateSpan result;
25510 PyObject * obj0 = 0 ;
25511 char *kwnames[] = {
25512 (char *) "years", NULL
25513 };
25514
25515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25516 {
25517 arg1 = (int)(SWIG_As_int(obj0));
25518 if (SWIG_arg_fail(1)) SWIG_fail;
25519 }
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = wxDateSpan::Years(arg1);
25523
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 {
25528 wxDateSpan * resultptr;
25529 resultptr = new wxDateSpan((wxDateSpan &)(result));
25530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25531 }
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj;
25540 wxDateSpan result;
25541 char *kwnames[] = {
25542 NULL
25543 };
25544
25545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = wxDateSpan::Year();
25549
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 {
25554 wxDateSpan * resultptr;
25555 resultptr = new wxDateSpan((wxDateSpan &)(result));
25556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25557 }
25558 return resultobj;
25559 fail:
25560 return NULL;
25561 }
25562
25563
25564 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25565 PyObject *resultobj;
25566 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25567 int arg2 ;
25568 wxDateSpan *result;
25569 PyObject * obj0 = 0 ;
25570 PyObject * obj1 = 0 ;
25571 char *kwnames[] = {
25572 (char *) "self",(char *) "n", NULL
25573 };
25574
25575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25577 if (SWIG_arg_fail(1)) SWIG_fail;
25578 {
25579 arg2 = (int)(SWIG_As_int(obj1));
25580 if (SWIG_arg_fail(2)) SWIG_fail;
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 {
25585 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25586 result = (wxDateSpan *) &_result_ref;
25587 }
25588
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25593 return resultobj;
25594 fail:
25595 return NULL;
25596 }
25597
25598
25599 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25600 PyObject *resultobj;
25601 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25602 int arg2 ;
25603 wxDateSpan *result;
25604 PyObject * obj0 = 0 ;
25605 PyObject * obj1 = 0 ;
25606 char *kwnames[] = {
25607 (char *) "self",(char *) "n", NULL
25608 };
25609
25610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25612 if (SWIG_arg_fail(1)) SWIG_fail;
25613 {
25614 arg2 = (int)(SWIG_As_int(obj1));
25615 if (SWIG_arg_fail(2)) SWIG_fail;
25616 }
25617 {
25618 PyThreadState* __tstate = wxPyBeginAllowThreads();
25619 {
25620 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25621 result = (wxDateSpan *) &_result_ref;
25622 }
25623
25624 wxPyEndAllowThreads(__tstate);
25625 if (PyErr_Occurred()) SWIG_fail;
25626 }
25627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25635 PyObject *resultobj;
25636 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25637 int arg2 ;
25638 wxDateSpan *result;
25639 PyObject * obj0 = 0 ;
25640 PyObject * obj1 = 0 ;
25641 char *kwnames[] = {
25642 (char *) "self",(char *) "n", NULL
25643 };
25644
25645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25647 if (SWIG_arg_fail(1)) SWIG_fail;
25648 {
25649 arg2 = (int)(SWIG_As_int(obj1));
25650 if (SWIG_arg_fail(2)) SWIG_fail;
25651 }
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 {
25655 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25656 result = (wxDateSpan *) &_result_ref;
25657 }
25658
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25672 int arg2 ;
25673 wxDateSpan *result;
25674 PyObject * obj0 = 0 ;
25675 PyObject * obj1 = 0 ;
25676 char *kwnames[] = {
25677 (char *) "self",(char *) "n", NULL
25678 };
25679
25680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25682 if (SWIG_arg_fail(1)) SWIG_fail;
25683 {
25684 arg2 = (int)(SWIG_As_int(obj1));
25685 if (SWIG_arg_fail(2)) SWIG_fail;
25686 }
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 {
25690 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25691 result = (wxDateSpan *) &_result_ref;
25692 }
25693
25694 wxPyEndAllowThreads(__tstate);
25695 if (PyErr_Occurred()) SWIG_fail;
25696 }
25697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj;
25706 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25707 int result;
25708 PyObject * obj0 = 0 ;
25709 char *kwnames[] = {
25710 (char *) "self", NULL
25711 };
25712
25713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25715 if (SWIG_arg_fail(1)) SWIG_fail;
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 result = (int)((wxDateSpan const *)arg1)->GetYears();
25719
25720 wxPyEndAllowThreads(__tstate);
25721 if (PyErr_Occurred()) SWIG_fail;
25722 }
25723 {
25724 resultobj = SWIG_From_int((int)(result));
25725 }
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj;
25734 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25735 int result;
25736 PyObject * obj0 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self", NULL
25739 };
25740
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 {
25745 PyThreadState* __tstate = wxPyBeginAllowThreads();
25746 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25747
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 {
25752 resultobj = SWIG_From_int((int)(result));
25753 }
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25761 PyObject *resultobj;
25762 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25763 int result;
25764 PyObject * obj0 = 0 ;
25765 char *kwnames[] = {
25766 (char *) "self", NULL
25767 };
25768
25769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(1)) SWIG_fail;
25772 {
25773 PyThreadState* __tstate = wxPyBeginAllowThreads();
25774 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25775
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 {
25780 resultobj = SWIG_From_int((int)(result));
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj;
25790 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25791 int result;
25792 PyObject * obj0 = 0 ;
25793 char *kwnames[] = {
25794 (char *) "self", NULL
25795 };
25796
25797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25799 if (SWIG_arg_fail(1)) SWIG_fail;
25800 {
25801 PyThreadState* __tstate = wxPyBeginAllowThreads();
25802 result = (int)((wxDateSpan const *)arg1)->GetDays();
25803
25804 wxPyEndAllowThreads(__tstate);
25805 if (PyErr_Occurred()) SWIG_fail;
25806 }
25807 {
25808 resultobj = SWIG_From_int((int)(result));
25809 }
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25819 int result;
25820 PyObject * obj0 = 0 ;
25821 char *kwnames[] = {
25822 (char *) "self", NULL
25823 };
25824
25825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25827 if (SWIG_arg_fail(1)) SWIG_fail;
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25831
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 {
25836 resultobj = SWIG_From_int((int)(result));
25837 }
25838 return resultobj;
25839 fail:
25840 return NULL;
25841 }
25842
25843
25844 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25845 PyObject *resultobj;
25846 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25847 wxDateSpan *arg2 = 0 ;
25848 wxDateSpan *result;
25849 PyObject * obj0 = 0 ;
25850 PyObject * obj1 = 0 ;
25851 char *kwnames[] = {
25852 (char *) "self",(char *) "other", NULL
25853 };
25854
25855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25857 if (SWIG_arg_fail(1)) SWIG_fail;
25858 {
25859 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25860 if (SWIG_arg_fail(2)) SWIG_fail;
25861 if (arg2 == NULL) {
25862 SWIG_null_ref("wxDateSpan");
25863 }
25864 if (SWIG_arg_fail(2)) SWIG_fail;
25865 }
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 {
25869 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25870 result = (wxDateSpan *) &_result_ref;
25871 }
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj;
25885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25886 wxDateSpan *arg2 = 0 ;
25887 wxDateSpan *result;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char *kwnames[] = {
25891 (char *) "self",(char *) "other", NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(1)) SWIG_fail;
25897 {
25898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25899 if (SWIG_arg_fail(2)) SWIG_fail;
25900 if (arg2 == NULL) {
25901 SWIG_null_ref("wxDateSpan");
25902 }
25903 if (SWIG_arg_fail(2)) SWIG_fail;
25904 }
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 {
25908 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25909 result = (wxDateSpan *) &_result_ref;
25910 }
25911
25912 wxPyEndAllowThreads(__tstate);
25913 if (PyErr_Occurred()) SWIG_fail;
25914 }
25915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25916 return resultobj;
25917 fail:
25918 return NULL;
25919 }
25920
25921
25922 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj;
25924 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25925 wxDateSpan *result;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 {
25937 wxDateSpan &_result_ref = (arg1)->Neg();
25938 result = (wxDateSpan *) &_result_ref;
25939 }
25940
25941 wxPyEndAllowThreads(__tstate);
25942 if (PyErr_Occurred()) SWIG_fail;
25943 }
25944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25952 PyObject *resultobj;
25953 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25954 int arg2 ;
25955 wxDateSpan *result;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char *kwnames[] = {
25959 (char *) "self",(char *) "factor", NULL
25960 };
25961
25962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25964 if (SWIG_arg_fail(1)) SWIG_fail;
25965 {
25966 arg2 = (int)(SWIG_As_int(obj1));
25967 if (SWIG_arg_fail(2)) SWIG_fail;
25968 }
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 {
25972 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25973 result = (wxDateSpan *) &_result_ref;
25974 }
25975
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj;
25988 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25989 wxDateSpan *arg2 = 0 ;
25990 wxDateSpan *result;
25991 PyObject * obj0 = 0 ;
25992 PyObject * obj1 = 0 ;
25993 char *kwnames[] = {
25994 (char *) "self",(char *) "other", NULL
25995 };
25996
25997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25999 if (SWIG_arg_fail(1)) SWIG_fail;
26000 {
26001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26002 if (SWIG_arg_fail(2)) SWIG_fail;
26003 if (arg2 == NULL) {
26004 SWIG_null_ref("wxDateSpan");
26005 }
26006 if (SWIG_arg_fail(2)) SWIG_fail;
26007 }
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 {
26011 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26012 result = (wxDateSpan *) &_result_ref;
26013 }
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj;
26027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26028 wxDateSpan *arg2 = 0 ;
26029 wxDateSpan *result;
26030 PyObject * obj0 = 0 ;
26031 PyObject * obj1 = 0 ;
26032 char *kwnames[] = {
26033 (char *) "self",(char *) "other", NULL
26034 };
26035
26036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26038 if (SWIG_arg_fail(1)) SWIG_fail;
26039 {
26040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26041 if (SWIG_arg_fail(2)) SWIG_fail;
26042 if (arg2 == NULL) {
26043 SWIG_null_ref("wxDateSpan");
26044 }
26045 if (SWIG_arg_fail(2)) SWIG_fail;
26046 }
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 {
26050 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26051 result = (wxDateSpan *) &_result_ref;
26052 }
26053
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26058 return resultobj;
26059 fail:
26060 return NULL;
26061 }
26062
26063
26064 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26065 PyObject *resultobj;
26066 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26067 wxDateSpan *result;
26068 PyObject * obj0 = 0 ;
26069 char *kwnames[] = {
26070 (char *) "self", NULL
26071 };
26072
26073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26075 if (SWIG_arg_fail(1)) SWIG_fail;
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 {
26079 wxDateSpan &_result_ref = (arg1)->operator -();
26080 result = (wxDateSpan *) &_result_ref;
26081 }
26082
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26096 int arg2 ;
26097 wxDateSpan *result;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "self",(char *) "factor", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 {
26108 arg2 = (int)(SWIG_As_int(obj1));
26109 if (SWIG_arg_fail(2)) SWIG_fail;
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 {
26114 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26115 result = (wxDateSpan *) &_result_ref;
26116 }
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj;
26130 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26131 wxDateSpan *arg2 = 0 ;
26132 wxDateSpan result;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char *kwnames[] = {
26136 (char *) "self",(char *) "other", NULL
26137 };
26138
26139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26141 if (SWIG_arg_fail(1)) SWIG_fail;
26142 {
26143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26144 if (SWIG_arg_fail(2)) SWIG_fail;
26145 if (arg2 == NULL) {
26146 SWIG_null_ref("wxDateSpan");
26147 }
26148 if (SWIG_arg_fail(2)) SWIG_fail;
26149 }
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26153
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 {
26158 wxDateSpan * resultptr;
26159 resultptr = new wxDateSpan((wxDateSpan &)(result));
26160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26161 }
26162 return resultobj;
26163 fail:
26164 return NULL;
26165 }
26166
26167
26168 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26169 PyObject *resultobj;
26170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26171 wxDateSpan *arg2 = 0 ;
26172 wxDateSpan result;
26173 PyObject * obj0 = 0 ;
26174 PyObject * obj1 = 0 ;
26175 char *kwnames[] = {
26176 (char *) "self",(char *) "other", NULL
26177 };
26178
26179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26181 if (SWIG_arg_fail(1)) SWIG_fail;
26182 {
26183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26184 if (SWIG_arg_fail(2)) SWIG_fail;
26185 if (arg2 == NULL) {
26186 SWIG_null_ref("wxDateSpan");
26187 }
26188 if (SWIG_arg_fail(2)) SWIG_fail;
26189 }
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 {
26198 wxDateSpan * resultptr;
26199 resultptr = new wxDateSpan((wxDateSpan &)(result));
26200 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26201 }
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj;
26210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26211 int arg2 ;
26212 wxDateSpan result;
26213 PyObject * obj0 = 0 ;
26214 PyObject * obj1 = 0 ;
26215 char *kwnames[] = {
26216 (char *) "self",(char *) "n", NULL
26217 };
26218
26219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26221 if (SWIG_arg_fail(1)) SWIG_fail;
26222 {
26223 arg2 = (int)(SWIG_As_int(obj1));
26224 if (SWIG_arg_fail(2)) SWIG_fail;
26225 }
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 result = wxDateSpan___mul__(arg1,arg2);
26229
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 wxDateSpan * resultptr;
26235 resultptr = new wxDateSpan((wxDateSpan &)(result));
26236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26237 }
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj;
26246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26247 int arg2 ;
26248 wxDateSpan result;
26249 PyObject * obj0 = 0 ;
26250 PyObject * obj1 = 0 ;
26251 char *kwnames[] = {
26252 (char *) "self",(char *) "n", NULL
26253 };
26254
26255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26257 if (SWIG_arg_fail(1)) SWIG_fail;
26258 {
26259 arg2 = (int)(SWIG_As_int(obj1));
26260 if (SWIG_arg_fail(2)) SWIG_fail;
26261 }
26262 {
26263 PyThreadState* __tstate = wxPyBeginAllowThreads();
26264 result = wxDateSpan___rmul__(arg1,arg2);
26265
26266 wxPyEndAllowThreads(__tstate);
26267 if (PyErr_Occurred()) SWIG_fail;
26268 }
26269 {
26270 wxDateSpan * resultptr;
26271 resultptr = new wxDateSpan((wxDateSpan &)(result));
26272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26273 }
26274 return resultobj;
26275 fail:
26276 return NULL;
26277 }
26278
26279
26280 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26281 PyObject *resultobj;
26282 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26283 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26284 bool result;
26285 PyObject * obj0 = 0 ;
26286 PyObject * obj1 = 0 ;
26287 char *kwnames[] = {
26288 (char *) "self",(char *) "other", NULL
26289 };
26290
26291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26293 if (SWIG_arg_fail(1)) SWIG_fail;
26294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26295 if (SWIG_arg_fail(2)) SWIG_fail;
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26299
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 {
26304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26305 }
26306 return resultobj;
26307 fail:
26308 return NULL;
26309 }
26310
26311
26312 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26313 PyObject *resultobj;
26314 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26315 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26316 bool result;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char *kwnames[] = {
26320 (char *) "self",(char *) "other", NULL
26321 };
26322
26323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26325 if (SWIG_arg_fail(1)) SWIG_fail;
26326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26327 if (SWIG_arg_fail(2)) SWIG_fail;
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 {
26336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26337 }
26338 return resultobj;
26339 fail:
26340 return NULL;
26341 }
26342
26343
26344 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26345 PyObject *obj;
26346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26347 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26348 Py_INCREF(obj);
26349 return Py_BuildValue((char *)"");
26350 }
26351 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26352 PyObject *resultobj;
26353 long result;
26354 char *kwnames[] = {
26355 NULL
26356 };
26357
26358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26359 {
26360 PyThreadState* __tstate = wxPyBeginAllowThreads();
26361 result = (long)wxGetLocalTime();
26362
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 {
26367 resultobj = SWIG_From_long((long)(result));
26368 }
26369 return resultobj;
26370 fail:
26371 return NULL;
26372 }
26373
26374
26375 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26376 PyObject *resultobj;
26377 long result;
26378 char *kwnames[] = {
26379 NULL
26380 };
26381
26382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = (long)wxGetUTCTime();
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 {
26391 resultobj = SWIG_From_long((long)(result));
26392 }
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26400 PyObject *resultobj;
26401 long result;
26402 char *kwnames[] = {
26403 NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (long)wxGetCurrentTime();
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 resultobj = SWIG_From_long((long)(result));
26416 }
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj;
26425 wxLongLong result;
26426 char *kwnames[] = {
26427 NULL
26428 };
26429
26430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26431 {
26432 PyThreadState* __tstate = wxPyBeginAllowThreads();
26433 result = wxGetLocalTimeMillis();
26434
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 {
26439 PyObject *hi, *lo, *shifter, *shifted;
26440 hi = PyLong_FromLong( (&result)->GetHi() );
26441 lo = PyLong_FromLong( (&result)->GetLo() );
26442 shifter = PyLong_FromLong(32);
26443 shifted = PyNumber_Lshift(hi, shifter);
26444 resultobj = PyNumber_Or(shifted, lo);
26445 Py_DECREF(hi);
26446 Py_DECREF(lo);
26447 Py_DECREF(shifter);
26448 Py_DECREF(shifted);
26449 }
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 static int _wrap_DefaultDateTime_set(PyObject *) {
26457 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26458 return 1;
26459 }
26460
26461
26462 static PyObject *_wrap_DefaultDateTime_get(void) {
26463 PyObject *pyobj;
26464
26465 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26466 return pyobj;
26467 }
26468
26469
26470 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26471 PyObject *resultobj;
26472 wxDataFormatId arg1 ;
26473 wxDataFormat *result;
26474 PyObject * obj0 = 0 ;
26475 char *kwnames[] = {
26476 (char *) "type", NULL
26477 };
26478
26479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26480 {
26481 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26482 if (SWIG_arg_fail(1)) SWIG_fail;
26483 }
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26487
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj;
26500 wxString *arg1 = 0 ;
26501 wxDataFormat *result;
26502 bool temp1 = false ;
26503 PyObject * obj0 = 0 ;
26504 char *kwnames[] = {
26505 (char *) "format", NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26509 {
26510 arg1 = wxString_in_helper(obj0);
26511 if (arg1 == NULL) SWIG_fail;
26512 temp1 = true;
26513 }
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26517
26518 wxPyEndAllowThreads(__tstate);
26519 if (PyErr_Occurred()) SWIG_fail;
26520 }
26521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26522 {
26523 if (temp1)
26524 delete arg1;
26525 }
26526 return resultobj;
26527 fail:
26528 {
26529 if (temp1)
26530 delete arg1;
26531 }
26532 return NULL;
26533 }
26534
26535
26536 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26537 PyObject *resultobj;
26538 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26539 PyObject * obj0 = 0 ;
26540 char *kwnames[] = {
26541 (char *) "self", NULL
26542 };
26543
26544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26546 if (SWIG_arg_fail(1)) SWIG_fail;
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 delete arg1;
26550
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 Py_INCREF(Py_None); resultobj = Py_None;
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26562 PyObject *resultobj;
26563 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26564 wxDataFormatId arg2 ;
26565 bool result;
26566 PyObject * obj0 = 0 ;
26567 PyObject * obj1 = 0 ;
26568
26569 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(1)) SWIG_fail;
26572 {
26573 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26574 if (SWIG_arg_fail(2)) SWIG_fail;
26575 }
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 {
26584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26585 }
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26593 PyObject *resultobj;
26594 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26595 wxDataFormatId arg2 ;
26596 bool result;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599
26600 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26602 if (SWIG_arg_fail(1)) SWIG_fail;
26603 {
26604 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26605 if (SWIG_arg_fail(2)) SWIG_fail;
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26624 PyObject *resultobj;
26625 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26626 wxDataFormat *arg2 = 0 ;
26627 bool result;
26628 PyObject * obj0 = 0 ;
26629 PyObject * obj1 = 0 ;
26630
26631 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26633 if (SWIG_arg_fail(1)) SWIG_fail;
26634 {
26635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26636 if (SWIG_arg_fail(2)) SWIG_fail;
26637 if (arg2 == NULL) {
26638 SWIG_null_ref("wxDataFormat");
26639 }
26640 if (SWIG_arg_fail(2)) SWIG_fail;
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26645
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 {
26650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26651 }
26652 return resultobj;
26653 fail:
26654 return NULL;
26655 }
26656
26657
26658 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26659 int argc;
26660 PyObject *argv[3];
26661 int ii;
26662
26663 argc = PyObject_Length(args);
26664 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26665 argv[ii] = PyTuple_GetItem(args,ii);
26666 }
26667 if (argc == 2) {
26668 int _v;
26669 {
26670 void *ptr;
26671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26672 _v = 0;
26673 PyErr_Clear();
26674 } else {
26675 _v = 1;
26676 }
26677 }
26678 if (_v) {
26679 {
26680 void *ptr = 0;
26681 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26682 _v = 0;
26683 PyErr_Clear();
26684 } else {
26685 _v = (ptr != 0);
26686 }
26687 }
26688 if (_v) {
26689 return _wrap_DataFormat___eq____SWIG_1(self,args);
26690 }
26691 }
26692 }
26693 if (argc == 2) {
26694 int _v;
26695 {
26696 void *ptr;
26697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26698 _v = 0;
26699 PyErr_Clear();
26700 } else {
26701 _v = 1;
26702 }
26703 }
26704 if (_v) {
26705 _v = SWIG_Check_int(argv[1]);
26706 if (_v) {
26707 return _wrap_DataFormat___eq____SWIG_0(self,args);
26708 }
26709 }
26710 }
26711
26712 Py_INCREF(Py_NotImplemented);
26713 return Py_NotImplemented;
26714 }
26715
26716
26717 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26718 PyObject *resultobj;
26719 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26720 wxDataFormat *arg2 = 0 ;
26721 bool result;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724
26725 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26727 if (SWIG_arg_fail(1)) SWIG_fail;
26728 {
26729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26730 if (SWIG_arg_fail(2)) SWIG_fail;
26731 if (arg2 == NULL) {
26732 SWIG_null_ref("wxDataFormat");
26733 }
26734 if (SWIG_arg_fail(2)) SWIG_fail;
26735 }
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26739
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 {
26744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26745 }
26746 return resultobj;
26747 fail:
26748 return NULL;
26749 }
26750
26751
26752 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26753 int argc;
26754 PyObject *argv[3];
26755 int ii;
26756
26757 argc = PyObject_Length(args);
26758 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26759 argv[ii] = PyTuple_GetItem(args,ii);
26760 }
26761 if (argc == 2) {
26762 int _v;
26763 {
26764 void *ptr;
26765 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26766 _v = 0;
26767 PyErr_Clear();
26768 } else {
26769 _v = 1;
26770 }
26771 }
26772 if (_v) {
26773 {
26774 void *ptr = 0;
26775 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26776 _v = 0;
26777 PyErr_Clear();
26778 } else {
26779 _v = (ptr != 0);
26780 }
26781 }
26782 if (_v) {
26783 return _wrap_DataFormat___ne____SWIG_1(self,args);
26784 }
26785 }
26786 }
26787 if (argc == 2) {
26788 int _v;
26789 {
26790 void *ptr;
26791 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26792 _v = 0;
26793 PyErr_Clear();
26794 } else {
26795 _v = 1;
26796 }
26797 }
26798 if (_v) {
26799 _v = SWIG_Check_int(argv[1]);
26800 if (_v) {
26801 return _wrap_DataFormat___ne____SWIG_0(self,args);
26802 }
26803 }
26804 }
26805
26806 Py_INCREF(Py_NotImplemented);
26807 return Py_NotImplemented;
26808 }
26809
26810
26811 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj;
26813 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26814 wxDataFormatId arg2 ;
26815 PyObject * obj0 = 0 ;
26816 PyObject * obj1 = 0 ;
26817 char *kwnames[] = {
26818 (char *) "self",(char *) "format", NULL
26819 };
26820
26821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26823 if (SWIG_arg_fail(1)) SWIG_fail;
26824 {
26825 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26826 if (SWIG_arg_fail(2)) SWIG_fail;
26827 }
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 (arg1)->SetType((wxDataFormatId )arg2);
26831
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 Py_INCREF(Py_None); resultobj = Py_None;
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj;
26844 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26845 wxDataFormatId result;
26846 PyObject * obj0 = 0 ;
26847 char *kwnames[] = {
26848 (char *) "self", NULL
26849 };
26850
26851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26853 if (SWIG_arg_fail(1)) SWIG_fail;
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26857
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 resultobj = SWIG_From_int((result));
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj;
26870 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26871 wxString result;
26872 PyObject * obj0 = 0 ;
26873 char *kwnames[] = {
26874 (char *) "self", NULL
26875 };
26876
26877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26879 if (SWIG_arg_fail(1)) SWIG_fail;
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = ((wxDataFormat const *)arg1)->GetId();
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 #if wxUSE_UNICODE
26889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26890 #else
26891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26892 #endif
26893 }
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj;
26902 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26903 wxString *arg2 = 0 ;
26904 bool temp2 = false ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 char *kwnames[] = {
26908 (char *) "self",(char *) "format", NULL
26909 };
26910
26911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26913 if (SWIG_arg_fail(1)) SWIG_fail;
26914 {
26915 arg2 = wxString_in_helper(obj1);
26916 if (arg2 == NULL) SWIG_fail;
26917 temp2 = true;
26918 }
26919 {
26920 PyThreadState* __tstate = wxPyBeginAllowThreads();
26921 (arg1)->SetId((wxString const &)*arg2);
26922
26923 wxPyEndAllowThreads(__tstate);
26924 if (PyErr_Occurred()) SWIG_fail;
26925 }
26926 Py_INCREF(Py_None); resultobj = Py_None;
26927 {
26928 if (temp2)
26929 delete arg2;
26930 }
26931 return resultobj;
26932 fail:
26933 {
26934 if (temp2)
26935 delete arg2;
26936 }
26937 return NULL;
26938 }
26939
26940
26941 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26942 PyObject *obj;
26943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26944 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26945 Py_INCREF(obj);
26946 return Py_BuildValue((char *)"");
26947 }
26948 static int _wrap_FormatInvalid_set(PyObject *) {
26949 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26950 return 1;
26951 }
26952
26953
26954 static PyObject *_wrap_FormatInvalid_get(void) {
26955 PyObject *pyobj;
26956
26957 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26958 return pyobj;
26959 }
26960
26961
26962 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26963 PyObject *resultobj;
26964 wxDataObject *arg1 = (wxDataObject *) 0 ;
26965 PyObject * obj0 = 0 ;
26966 char *kwnames[] = {
26967 (char *) "self", NULL
26968 };
26969
26970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26972 if (SWIG_arg_fail(1)) SWIG_fail;
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 delete arg1;
26976
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 Py_INCREF(Py_None); resultobj = Py_None;
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxDataObject *arg1 = (wxDataObject *) 0 ;
26990 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26991 SwigValueWrapper<wxDataFormat > result;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "dir", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 if (obj1) {
27002 {
27003 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27004 if (SWIG_arg_fail(2)) SWIG_fail;
27005 }
27006 }
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27010
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 {
27015 wxDataFormat * resultptr;
27016 resultptr = new wxDataFormat((wxDataFormat &)(result));
27017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27018 }
27019 return resultobj;
27020 fail:
27021 return NULL;
27022 }
27023
27024
27025 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27026 PyObject *resultobj;
27027 wxDataObject *arg1 = (wxDataObject *) 0 ;
27028 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27029 size_t result;
27030 PyObject * obj0 = 0 ;
27031 PyObject * obj1 = 0 ;
27032 char *kwnames[] = {
27033 (char *) "self",(char *) "dir", NULL
27034 };
27035
27036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27038 if (SWIG_arg_fail(1)) SWIG_fail;
27039 if (obj1) {
27040 {
27041 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27042 if (SWIG_arg_fail(2)) SWIG_fail;
27043 }
27044 }
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27048
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 {
27053 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27054 }
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27062 PyObject *resultobj;
27063 wxDataObject *arg1 = (wxDataObject *) 0 ;
27064 wxDataFormat *arg2 = 0 ;
27065 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27066 bool result;
27067 PyObject * obj0 = 0 ;
27068 PyObject * obj1 = 0 ;
27069 PyObject * obj2 = 0 ;
27070 char *kwnames[] = {
27071 (char *) "self",(char *) "format",(char *) "dir", NULL
27072 };
27073
27074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27076 if (SWIG_arg_fail(1)) SWIG_fail;
27077 {
27078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(2)) SWIG_fail;
27080 if (arg2 == NULL) {
27081 SWIG_null_ref("wxDataFormat");
27082 }
27083 if (SWIG_arg_fail(2)) SWIG_fail;
27084 }
27085 if (obj2) {
27086 {
27087 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27088 if (SWIG_arg_fail(3)) SWIG_fail;
27089 }
27090 }
27091 {
27092 PyThreadState* __tstate = wxPyBeginAllowThreads();
27093 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27094
27095 wxPyEndAllowThreads(__tstate);
27096 if (PyErr_Occurred()) SWIG_fail;
27097 }
27098 {
27099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27100 }
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj;
27109 wxDataObject *arg1 = (wxDataObject *) 0 ;
27110 wxDataFormat *arg2 = 0 ;
27111 size_t result;
27112 PyObject * obj0 = 0 ;
27113 PyObject * obj1 = 0 ;
27114 char *kwnames[] = {
27115 (char *) "self",(char *) "format", NULL
27116 };
27117
27118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27120 if (SWIG_arg_fail(1)) SWIG_fail;
27121 {
27122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(2)) SWIG_fail;
27124 if (arg2 == NULL) {
27125 SWIG_null_ref("wxDataFormat");
27126 }
27127 if (SWIG_arg_fail(2)) SWIG_fail;
27128 }
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27132
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 {
27137 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27138 }
27139 return resultobj;
27140 fail:
27141 return NULL;
27142 }
27143
27144
27145 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj;
27147 wxDataObject *arg1 = (wxDataObject *) 0 ;
27148 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27149 PyObject *result;
27150 PyObject * obj0 = 0 ;
27151 PyObject * obj1 = 0 ;
27152 char *kwnames[] = {
27153 (char *) "self",(char *) "dir", NULL
27154 };
27155
27156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27158 if (SWIG_arg_fail(1)) SWIG_fail;
27159 if (obj1) {
27160 {
27161 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27162 if (SWIG_arg_fail(2)) SWIG_fail;
27163 }
27164 }
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27168
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = result;
27173 return resultobj;
27174 fail:
27175 return NULL;
27176 }
27177
27178
27179 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27180 PyObject *resultobj;
27181 wxDataObject *arg1 = (wxDataObject *) 0 ;
27182 wxDataFormat *arg2 = 0 ;
27183 PyObject *result;
27184 PyObject * obj0 = 0 ;
27185 PyObject * obj1 = 0 ;
27186 char *kwnames[] = {
27187 (char *) "self",(char *) "format", NULL
27188 };
27189
27190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27192 if (SWIG_arg_fail(1)) SWIG_fail;
27193 {
27194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27195 if (SWIG_arg_fail(2)) SWIG_fail;
27196 if (arg2 == NULL) {
27197 SWIG_null_ref("wxDataFormat");
27198 }
27199 if (SWIG_arg_fail(2)) SWIG_fail;
27200 }
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27204
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = result;
27209 return resultobj;
27210 fail:
27211 return NULL;
27212 }
27213
27214
27215 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27216 PyObject *resultobj;
27217 wxDataObject *arg1 = (wxDataObject *) 0 ;
27218 wxDataFormat *arg2 = 0 ;
27219 PyObject *arg3 = (PyObject *) 0 ;
27220 bool result;
27221 PyObject * obj0 = 0 ;
27222 PyObject * obj1 = 0 ;
27223 PyObject * obj2 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "self",(char *) "format",(char *) "data", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27230 if (SWIG_arg_fail(1)) SWIG_fail;
27231 {
27232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27233 if (SWIG_arg_fail(2)) SWIG_fail;
27234 if (arg2 == NULL) {
27235 SWIG_null_ref("wxDataFormat");
27236 }
27237 if (SWIG_arg_fail(2)) SWIG_fail;
27238 }
27239 arg3 = obj2;
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27243
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27257 PyObject *obj;
27258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27259 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27260 Py_INCREF(obj);
27261 return Py_BuildValue((char *)"");
27262 }
27263 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27264 PyObject *resultobj;
27265 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27266 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27267 wxDataObjectSimple *result;
27268 PyObject * obj0 = 0 ;
27269 char *kwnames[] = {
27270 (char *) "format", NULL
27271 };
27272
27273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27274 if (obj0) {
27275 {
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 if (arg1 == NULL) {
27279 SWIG_null_ref("wxDataFormat");
27280 }
27281 if (SWIG_arg_fail(1)) SWIG_fail;
27282 }
27283 }
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27287
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj;
27300 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27301 wxDataFormat *result;
27302 PyObject * obj0 = 0 ;
27303 char *kwnames[] = {
27304 (char *) "self", NULL
27305 };
27306
27307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(1)) SWIG_fail;
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 {
27313 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27314 result = (wxDataFormat *) &_result_ref;
27315 }
27316
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj;
27329 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27330 wxDataFormat *arg2 = 0 ;
27331 PyObject * obj0 = 0 ;
27332 PyObject * obj1 = 0 ;
27333 char *kwnames[] = {
27334 (char *) "self",(char *) "format", NULL
27335 };
27336
27337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27339 if (SWIG_arg_fail(1)) SWIG_fail;
27340 {
27341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27342 if (SWIG_arg_fail(2)) SWIG_fail;
27343 if (arg2 == NULL) {
27344 SWIG_null_ref("wxDataFormat");
27345 }
27346 if (SWIG_arg_fail(2)) SWIG_fail;
27347 }
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27351
27352 wxPyEndAllowThreads(__tstate);
27353 if (PyErr_Occurred()) SWIG_fail;
27354 }
27355 Py_INCREF(Py_None); resultobj = Py_None;
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27363 PyObject *resultobj;
27364 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27365 size_t result;
27366 PyObject * obj0 = 0 ;
27367 char *kwnames[] = {
27368 (char *) "self", NULL
27369 };
27370
27371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27373 if (SWIG_arg_fail(1)) SWIG_fail;
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27377
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 {
27382 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27383 }
27384 return resultobj;
27385 fail:
27386 return NULL;
27387 }
27388
27389
27390 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj;
27392 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27393 PyObject *result;
27394 PyObject * obj0 = 0 ;
27395 char *kwnames[] = {
27396 (char *) "self", NULL
27397 };
27398
27399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27401 if (SWIG_arg_fail(1)) SWIG_fail;
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27405
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = result;
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj;
27418 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27419 PyObject *arg2 = (PyObject *) 0 ;
27420 bool result;
27421 PyObject * obj0 = 0 ;
27422 PyObject * obj1 = 0 ;
27423 char *kwnames[] = {
27424 (char *) "self",(char *) "data", NULL
27425 };
27426
27427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27429 if (SWIG_arg_fail(1)) SWIG_fail;
27430 arg2 = obj1;
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27434
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 {
27439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27440 }
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27448 PyObject *obj;
27449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27450 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27451 Py_INCREF(obj);
27452 return Py_BuildValue((char *)"");
27453 }
27454 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27455 PyObject *resultobj;
27456 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27457 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27458 wxPyDataObjectSimple *result;
27459 PyObject * obj0 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "format", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27465 if (obj0) {
27466 {
27467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27468 if (SWIG_arg_fail(1)) SWIG_fail;
27469 if (arg1 == NULL) {
27470 SWIG_null_ref("wxDataFormat");
27471 }
27472 if (SWIG_arg_fail(1)) SWIG_fail;
27473 }
27474 }
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27478
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27492 PyObject *arg2 = (PyObject *) 0 ;
27493 PyObject *arg3 = (PyObject *) 0 ;
27494 PyObject * obj0 = 0 ;
27495 PyObject * obj1 = 0 ;
27496 PyObject * obj2 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self",(char *) "self",(char *) "_class", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 arg2 = obj1;
27505 arg3 = obj2;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 (arg1)->_setCallbackInfo(arg2,arg3);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 Py_INCREF(Py_None); resultobj = Py_None;
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27521 PyObject *obj;
27522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27523 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27524 Py_INCREF(obj);
27525 return Py_BuildValue((char *)"");
27526 }
27527 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj;
27529 wxDataObjectComposite *result;
27530 char *kwnames[] = {
27531 NULL
27532 };
27533
27534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27538
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj;
27551 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27552 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27553 bool arg3 = (bool) false ;
27554 PyObject * obj0 = 0 ;
27555 PyObject * obj1 = 0 ;
27556 PyObject * obj2 = 0 ;
27557 char *kwnames[] = {
27558 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27559 };
27560
27561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27563 if (SWIG_arg_fail(1)) SWIG_fail;
27564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27565 if (SWIG_arg_fail(2)) SWIG_fail;
27566 if (obj2) {
27567 {
27568 arg3 = (bool)(SWIG_As_bool(obj2));
27569 if (SWIG_arg_fail(3)) SWIG_fail;
27570 }
27571 }
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 (arg1)->Add(arg2,arg3);
27575
27576 wxPyEndAllowThreads(__tstate);
27577 if (PyErr_Occurred()) SWIG_fail;
27578 }
27579 Py_INCREF(Py_None); resultobj = Py_None;
27580 return resultobj;
27581 fail:
27582 return NULL;
27583 }
27584
27585
27586 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27587 PyObject *obj;
27588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27589 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27590 Py_INCREF(obj);
27591 return Py_BuildValue((char *)"");
27592 }
27593 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxString const &arg1_defvalue = wxPyEmptyString ;
27596 wxString *arg1 = (wxString *) &arg1_defvalue ;
27597 wxTextDataObject *result;
27598 bool temp1 = false ;
27599 PyObject * obj0 = 0 ;
27600 char *kwnames[] = {
27601 (char *) "text", NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27605 if (obj0) {
27606 {
27607 arg1 = wxString_in_helper(obj0);
27608 if (arg1 == NULL) SWIG_fail;
27609 temp1 = true;
27610 }
27611 }
27612 {
27613 PyThreadState* __tstate = wxPyBeginAllowThreads();
27614 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27615
27616 wxPyEndAllowThreads(__tstate);
27617 if (PyErr_Occurred()) SWIG_fail;
27618 }
27619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27620 {
27621 if (temp1)
27622 delete arg1;
27623 }
27624 return resultobj;
27625 fail:
27626 {
27627 if (temp1)
27628 delete arg1;
27629 }
27630 return NULL;
27631 }
27632
27633
27634 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj;
27636 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27637 size_t result;
27638 PyObject * obj0 = 0 ;
27639 char *kwnames[] = {
27640 (char *) "self", NULL
27641 };
27642
27643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27645 if (SWIG_arg_fail(1)) SWIG_fail;
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (size_t)(arg1)->GetTextLength();
27649
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 {
27654 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27655 }
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27663 PyObject *resultobj;
27664 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27665 wxString result;
27666 PyObject * obj0 = 0 ;
27667 char *kwnames[] = {
27668 (char *) "self", NULL
27669 };
27670
27671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27673 if (SWIG_arg_fail(1)) SWIG_fail;
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 result = (arg1)->GetText();
27677
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 {
27682 #if wxUSE_UNICODE
27683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27684 #else
27685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27686 #endif
27687 }
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj;
27696 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27697 wxString *arg2 = 0 ;
27698 bool temp2 = false ;
27699 PyObject * obj0 = 0 ;
27700 PyObject * obj1 = 0 ;
27701 char *kwnames[] = {
27702 (char *) "self",(char *) "text", NULL
27703 };
27704
27705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27707 if (SWIG_arg_fail(1)) SWIG_fail;
27708 {
27709 arg2 = wxString_in_helper(obj1);
27710 if (arg2 == NULL) SWIG_fail;
27711 temp2 = true;
27712 }
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->SetText((wxString const &)*arg2);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 Py_INCREF(Py_None); resultobj = Py_None;
27721 {
27722 if (temp2)
27723 delete arg2;
27724 }
27725 return resultobj;
27726 fail:
27727 {
27728 if (temp2)
27729 delete arg2;
27730 }
27731 return NULL;
27732 }
27733
27734
27735 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27736 PyObject *obj;
27737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27738 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27739 Py_INCREF(obj);
27740 return Py_BuildValue((char *)"");
27741 }
27742 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27743 PyObject *resultobj;
27744 wxString const &arg1_defvalue = wxPyEmptyString ;
27745 wxString *arg1 = (wxString *) &arg1_defvalue ;
27746 wxPyTextDataObject *result;
27747 bool temp1 = false ;
27748 PyObject * obj0 = 0 ;
27749 char *kwnames[] = {
27750 (char *) "text", NULL
27751 };
27752
27753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27754 if (obj0) {
27755 {
27756 arg1 = wxString_in_helper(obj0);
27757 if (arg1 == NULL) SWIG_fail;
27758 temp1 = true;
27759 }
27760 }
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27764
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27769 {
27770 if (temp1)
27771 delete arg1;
27772 }
27773 return resultobj;
27774 fail:
27775 {
27776 if (temp1)
27777 delete arg1;
27778 }
27779 return NULL;
27780 }
27781
27782
27783 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27784 PyObject *resultobj;
27785 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27786 PyObject *arg2 = (PyObject *) 0 ;
27787 PyObject *arg3 = (PyObject *) 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 PyObject * obj2 = 0 ;
27791 char *kwnames[] = {
27792 (char *) "self",(char *) "self",(char *) "_class", NULL
27793 };
27794
27795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27797 if (SWIG_arg_fail(1)) SWIG_fail;
27798 arg2 = obj1;
27799 arg3 = obj2;
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 (arg1)->_setCallbackInfo(arg2,arg3);
27803
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 Py_INCREF(Py_None); resultobj = Py_None;
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27815 PyObject *obj;
27816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27817 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27818 Py_INCREF(obj);
27819 return Py_BuildValue((char *)"");
27820 }
27821 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27822 PyObject *resultobj;
27823 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27824 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27825 wxBitmapDataObject *result;
27826 PyObject * obj0 = 0 ;
27827 char *kwnames[] = {
27828 (char *) "bitmap", NULL
27829 };
27830
27831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27832 if (obj0) {
27833 {
27834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27835 if (SWIG_arg_fail(1)) SWIG_fail;
27836 if (arg1 == NULL) {
27837 SWIG_null_ref("wxBitmap");
27838 }
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 }
27841 }
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27859 wxBitmap result;
27860 PyObject * obj0 = 0 ;
27861 char *kwnames[] = {
27862 (char *) "self", NULL
27863 };
27864
27865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 wxBitmap * resultptr;
27877 resultptr = new wxBitmap((wxBitmap &)(result));
27878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27889 wxBitmap *arg2 = 0 ;
27890 PyObject * obj0 = 0 ;
27891 PyObject * obj1 = 0 ;
27892 char *kwnames[] = {
27893 (char *) "self",(char *) "bitmap", NULL
27894 };
27895
27896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27898 if (SWIG_arg_fail(1)) SWIG_fail;
27899 {
27900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27901 if (SWIG_arg_fail(2)) SWIG_fail;
27902 if (arg2 == NULL) {
27903 SWIG_null_ref("wxBitmap");
27904 }
27905 if (SWIG_arg_fail(2)) SWIG_fail;
27906 }
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27910
27911 wxPyEndAllowThreads(__tstate);
27912 if (PyErr_Occurred()) SWIG_fail;
27913 }
27914 Py_INCREF(Py_None); resultobj = Py_None;
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27922 PyObject *obj;
27923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27924 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27925 Py_INCREF(obj);
27926 return Py_BuildValue((char *)"");
27927 }
27928 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27929 PyObject *resultobj;
27930 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27931 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27932 wxPyBitmapDataObject *result;
27933 PyObject * obj0 = 0 ;
27934 char *kwnames[] = {
27935 (char *) "bitmap", NULL
27936 };
27937
27938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27939 if (obj0) {
27940 {
27941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27942 if (SWIG_arg_fail(1)) SWIG_fail;
27943 if (arg1 == NULL) {
27944 SWIG_null_ref("wxBitmap");
27945 }
27946 if (SWIG_arg_fail(1)) SWIG_fail;
27947 }
27948 }
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj;
27965 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27966 PyObject *arg2 = (PyObject *) 0 ;
27967 PyObject *arg3 = (PyObject *) 0 ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 PyObject * obj2 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "self",(char *) "_class", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 arg2 = obj1;
27979 arg3 = obj2;
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 (arg1)->_setCallbackInfo(arg2,arg3);
27983
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 Py_INCREF(Py_None); resultobj = Py_None;
27988 return resultobj;
27989 fail:
27990 return NULL;
27991 }
27992
27993
27994 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27995 PyObject *obj;
27996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27997 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27998 Py_INCREF(obj);
27999 return Py_BuildValue((char *)"");
28000 }
28001 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28002 PyObject *resultobj;
28003 wxFileDataObject *result;
28004 char *kwnames[] = {
28005 NULL
28006 };
28007
28008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 result = (wxFileDataObject *)new wxFileDataObject();
28012
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28024 PyObject *resultobj;
28025 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28026 wxArrayString *result;
28027 PyObject * obj0 = 0 ;
28028 char *kwnames[] = {
28029 (char *) "self", NULL
28030 };
28031
28032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 {
28038 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28039 result = (wxArrayString *) &_result_ref;
28040 }
28041
28042 wxPyEndAllowThreads(__tstate);
28043 if (PyErr_Occurred()) SWIG_fail;
28044 }
28045 {
28046 resultobj = wxArrayString2PyList_helper(*result);
28047 }
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28055 PyObject *resultobj;
28056 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28057 wxString *arg2 = 0 ;
28058 bool temp2 = false ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char *kwnames[] = {
28062 (char *) "self",(char *) "filename", NULL
28063 };
28064
28065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 {
28069 arg2 = wxString_in_helper(obj1);
28070 if (arg2 == NULL) SWIG_fail;
28071 temp2 = true;
28072 }
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 (arg1)->AddFile((wxString const &)*arg2);
28076
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 Py_INCREF(Py_None); resultobj = Py_None;
28081 {
28082 if (temp2)
28083 delete arg2;
28084 }
28085 return resultobj;
28086 fail:
28087 {
28088 if (temp2)
28089 delete arg2;
28090 }
28091 return NULL;
28092 }
28093
28094
28095 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28096 PyObject *obj;
28097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28098 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28099 Py_INCREF(obj);
28100 return Py_BuildValue((char *)"");
28101 }
28102 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28103 PyObject *resultobj;
28104 wxDataFormat *arg1 = 0 ;
28105 wxCustomDataObject *result;
28106 PyObject * obj0 = 0 ;
28107
28108 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28109 {
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 if (arg1 == NULL) {
28113 SWIG_null_ref("wxDataFormat");
28114 }
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 }
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28120
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28132 PyObject *resultobj;
28133 wxString *arg1 = 0 ;
28134 wxCustomDataObject *result;
28135 bool temp1 = false ;
28136 PyObject * obj0 = 0 ;
28137
28138 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28139 {
28140 arg1 = wxString_in_helper(obj0);
28141 if (arg1 == NULL) SWIG_fail;
28142 temp1 = true;
28143 }
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28147
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28152 {
28153 if (temp1)
28154 delete arg1;
28155 }
28156 return resultobj;
28157 fail:
28158 {
28159 if (temp1)
28160 delete arg1;
28161 }
28162 return NULL;
28163 }
28164
28165
28166 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28167 PyObject *resultobj;
28168 wxCustomDataObject *result;
28169
28170 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (wxCustomDataObject *)new wxCustomDataObject();
28174
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28186 int argc;
28187 PyObject *argv[2];
28188 int ii;
28189
28190 argc = PyObject_Length(args);
28191 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28192 argv[ii] = PyTuple_GetItem(args,ii);
28193 }
28194 if (argc == 0) {
28195 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28196 }
28197 if (argc == 1) {
28198 int _v;
28199 {
28200 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28201 }
28202 if (_v) {
28203 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28204 }
28205 }
28206 if (argc == 1) {
28207 int _v;
28208 {
28209 void *ptr = 0;
28210 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28211 _v = 0;
28212 PyErr_Clear();
28213 } else {
28214 _v = (ptr != 0);
28215 }
28216 }
28217 if (_v) {
28218 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28219 }
28220 }
28221
28222 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28223 return NULL;
28224 }
28225
28226
28227 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj;
28229 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28230 PyObject *arg2 = (PyObject *) 0 ;
28231 bool result;
28232 PyObject * obj0 = 0 ;
28233 PyObject * obj1 = 0 ;
28234 char *kwnames[] = {
28235 (char *) "self",(char *) "data", NULL
28236 };
28237
28238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28240 if (SWIG_arg_fail(1)) SWIG_fail;
28241 arg2 = obj1;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28245
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28261 size_t result;
28262 PyObject * obj0 = 0 ;
28263 char *kwnames[] = {
28264 (char *) "self", NULL
28265 };
28266
28267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28269 if (SWIG_arg_fail(1)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (size_t)(arg1)->GetSize();
28273
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 {
28278 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28279 }
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj;
28288 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28289 PyObject *result;
28290 PyObject * obj0 = 0 ;
28291 char *kwnames[] = {
28292 (char *) "self", NULL
28293 };
28294
28295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28297 if (SWIG_arg_fail(1)) SWIG_fail;
28298 {
28299 PyThreadState* __tstate = wxPyBeginAllowThreads();
28300 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28301
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = result;
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28313 PyObject *obj;
28314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28315 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28316 Py_INCREF(obj);
28317 return Py_BuildValue((char *)"");
28318 }
28319 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxURLDataObject *result;
28322 char *kwnames[] = {
28323 NULL
28324 };
28325
28326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (wxURLDataObject *)new wxURLDataObject();
28330
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28342 PyObject *resultobj;
28343 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28344 wxString result;
28345 PyObject * obj0 = 0 ;
28346 char *kwnames[] = {
28347 (char *) "self", NULL
28348 };
28349
28350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28352 if (SWIG_arg_fail(1)) SWIG_fail;
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (arg1)->GetURL();
28356
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 {
28361 #if wxUSE_UNICODE
28362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28363 #else
28364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28365 #endif
28366 }
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj;
28375 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28376 wxString *arg2 = 0 ;
28377 bool temp2 = false ;
28378 PyObject * obj0 = 0 ;
28379 PyObject * obj1 = 0 ;
28380 char *kwnames[] = {
28381 (char *) "self",(char *) "url", NULL
28382 };
28383
28384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28386 if (SWIG_arg_fail(1)) SWIG_fail;
28387 {
28388 arg2 = wxString_in_helper(obj1);
28389 if (arg2 == NULL) SWIG_fail;
28390 temp2 = true;
28391 }
28392 {
28393 PyThreadState* __tstate = wxPyBeginAllowThreads();
28394 (arg1)->SetURL((wxString const &)*arg2);
28395
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 Py_INCREF(Py_None); resultobj = Py_None;
28400 {
28401 if (temp2)
28402 delete arg2;
28403 }
28404 return resultobj;
28405 fail:
28406 {
28407 if (temp2)
28408 delete arg2;
28409 }
28410 return NULL;
28411 }
28412
28413
28414 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28415 PyObject *obj;
28416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28417 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28418 Py_INCREF(obj);
28419 return Py_BuildValue((char *)"");
28420 }
28421 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28422 PyObject *resultobj;
28423 wxMetafileDataObject *result;
28424 char *kwnames[] = {
28425 NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28444 PyObject *obj;
28445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28446 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28447 Py_INCREF(obj);
28448 return Py_BuildValue((char *)"");
28449 }
28450 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj;
28452 wxDragResult arg1 ;
28453 bool result;
28454 PyObject * obj0 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "res", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28460 {
28461 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28467
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 {
28472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28473 }
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxWindow *arg1 = (wxWindow *) 0 ;
28483 wxIcon const &arg2_defvalue = wxNullIcon ;
28484 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28485 wxIcon const &arg3_defvalue = wxNullIcon ;
28486 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28487 wxIcon const &arg4_defvalue = wxNullIcon ;
28488 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28489 wxPyDropSource *result;
28490 PyObject * obj0 = 0 ;
28491 PyObject * obj1 = 0 ;
28492 PyObject * obj2 = 0 ;
28493 PyObject * obj3 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 if (obj1) {
28502 {
28503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28504 if (SWIG_arg_fail(2)) SWIG_fail;
28505 if (arg2 == NULL) {
28506 SWIG_null_ref("wxIcon");
28507 }
28508 if (SWIG_arg_fail(2)) SWIG_fail;
28509 }
28510 }
28511 if (obj2) {
28512 {
28513 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28514 if (SWIG_arg_fail(3)) SWIG_fail;
28515 if (arg3 == NULL) {
28516 SWIG_null_ref("wxIcon");
28517 }
28518 if (SWIG_arg_fail(3)) SWIG_fail;
28519 }
28520 }
28521 if (obj3) {
28522 {
28523 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(4)) SWIG_fail;
28525 if (arg4 == NULL) {
28526 SWIG_null_ref("wxIcon");
28527 }
28528 if (SWIG_arg_fail(4)) SWIG_fail;
28529 }
28530 }
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28534
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28546 PyObject *resultobj;
28547 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28548 PyObject *arg2 = (PyObject *) 0 ;
28549 PyObject *arg3 = (PyObject *) 0 ;
28550 int arg4 ;
28551 PyObject * obj0 = 0 ;
28552 PyObject * obj1 = 0 ;
28553 PyObject * obj2 = 0 ;
28554 PyObject * obj3 = 0 ;
28555 char *kwnames[] = {
28556 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28557 };
28558
28559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28561 if (SWIG_arg_fail(1)) SWIG_fail;
28562 arg2 = obj1;
28563 arg3 = obj2;
28564 {
28565 arg4 = (int)(SWIG_As_int(obj3));
28566 if (SWIG_arg_fail(4)) SWIG_fail;
28567 }
28568 {
28569 PyThreadState* __tstate = wxPyBeginAllowThreads();
28570 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28571
28572 wxPyEndAllowThreads(__tstate);
28573 if (PyErr_Occurred()) SWIG_fail;
28574 }
28575 Py_INCREF(Py_None); resultobj = Py_None;
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj;
28584 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28585 PyObject * obj0 = 0 ;
28586 char *kwnames[] = {
28587 (char *) "self", NULL
28588 };
28589
28590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28592 if (SWIG_arg_fail(1)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 delete arg1;
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 Py_INCREF(Py_None); resultobj = Py_None;
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj;
28609 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28610 wxDataObject *arg2 = 0 ;
28611 PyObject * obj0 = 0 ;
28612 PyObject * obj1 = 0 ;
28613 char *kwnames[] = {
28614 (char *) "self",(char *) "data", NULL
28615 };
28616
28617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28619 if (SWIG_arg_fail(1)) SWIG_fail;
28620 {
28621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(2)) SWIG_fail;
28623 if (arg2 == NULL) {
28624 SWIG_null_ref("wxDataObject");
28625 }
28626 if (SWIG_arg_fail(2)) SWIG_fail;
28627 }
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 (arg1)->SetData(*arg2);
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 Py_INCREF(Py_None); resultobj = Py_None;
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28645 wxDataObject *result;
28646 PyObject * obj0 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxDataObject *)(arg1)->GetDataObject();
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28671 wxDragResult arg2 ;
28672 wxCursor *arg3 = 0 ;
28673 PyObject * obj0 = 0 ;
28674 PyObject * obj1 = 0 ;
28675 PyObject * obj2 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self",(char *) "res",(char *) "cursor", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28685 if (SWIG_arg_fail(2)) SWIG_fail;
28686 }
28687 {
28688 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(3)) SWIG_fail;
28690 if (arg3 == NULL) {
28691 SWIG_null_ref("wxCursor");
28692 }
28693 if (SWIG_arg_fail(3)) SWIG_fail;
28694 }
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28698
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 Py_INCREF(Py_None); resultobj = Py_None;
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28710 PyObject *resultobj;
28711 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28712 int arg2 = (int) wxDrag_CopyOnly ;
28713 wxDragResult result;
28714 PyObject * obj0 = 0 ;
28715 PyObject * obj1 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self",(char *) "flags", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 if (obj1) {
28724 {
28725 arg2 = (int)(SWIG_As_int(obj1));
28726 if (SWIG_arg_fail(2)) SWIG_fail;
28727 }
28728 }
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28732
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_From_int((result));
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj;
28745 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28746 wxDragResult arg2 ;
28747 bool result;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char *kwnames[] = {
28751 (char *) "self",(char *) "effect", NULL
28752 };
28753
28754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 {
28758 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28759 if (SWIG_arg_fail(2)) SWIG_fail;
28760 }
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28770 }
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28778 PyObject *obj;
28779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28780 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28781 Py_INCREF(obj);
28782 return Py_BuildValue((char *)"");
28783 }
28784 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28785 PyObject *resultobj;
28786 wxDataObject *arg1 = (wxDataObject *) NULL ;
28787 wxPyDropTarget *result;
28788 PyObject * obj0 = 0 ;
28789 char *kwnames[] = {
28790 (char *) "dataObject", NULL
28791 };
28792
28793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28794 if (obj0) {
28795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28796 if (SWIG_arg_fail(1)) SWIG_fail;
28797 }
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28815 PyObject *arg2 = (PyObject *) 0 ;
28816 PyObject *arg3 = (PyObject *) 0 ;
28817 PyObject * obj0 = 0 ;
28818 PyObject * obj1 = 0 ;
28819 PyObject * obj2 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self",(char *) "self",(char *) "_class", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 arg2 = obj1;
28828 arg3 = obj2;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 (arg1)->_setCallbackInfo(arg2,arg3);
28832
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 Py_INCREF(Py_None); resultobj = Py_None;
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj;
28845 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28846 PyObject * obj0 = 0 ;
28847 char *kwnames[] = {
28848 (char *) "self", NULL
28849 };
28850
28851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28853 if (SWIG_arg_fail(1)) SWIG_fail;
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 delete arg1;
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 Py_INCREF(Py_None); resultobj = Py_None;
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28869 PyObject *resultobj;
28870 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28871 wxDataObject *result;
28872 PyObject * obj0 = 0 ;
28873 char *kwnames[] = {
28874 (char *) "self", NULL
28875 };
28876
28877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(1)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 result = (wxDataObject *)(arg1)->GetDataObject();
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj;
28896 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28897 wxDataObject *arg2 = (wxDataObject *) 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char *kwnames[] = {
28901 (char *) "self",(char *) "dataObject", NULL
28902 };
28903
28904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28906 if (SWIG_arg_fail(1)) SWIG_fail;
28907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28908 if (SWIG_arg_fail(2)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->SetDataObject(arg2);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 Py_INCREF(Py_None); resultobj = Py_None;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28926 int arg2 ;
28927 int arg3 ;
28928 wxDragResult arg4 ;
28929 wxDragResult result;
28930 PyObject * obj0 = 0 ;
28931 PyObject * obj1 = 0 ;
28932 PyObject * obj2 = 0 ;
28933 PyObject * obj3 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = (int)(SWIG_As_int(obj1));
28943 if (SWIG_arg_fail(2)) SWIG_fail;
28944 }
28945 {
28946 arg3 = (int)(SWIG_As_int(obj2));
28947 if (SWIG_arg_fail(3)) SWIG_fail;
28948 }
28949 {
28950 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28951 if (SWIG_arg_fail(4)) SWIG_fail;
28952 }
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int((result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj;
28969 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28970 int arg2 ;
28971 int arg3 ;
28972 wxDragResult arg4 ;
28973 wxDragResult result;
28974 PyObject * obj0 = 0 ;
28975 PyObject * obj1 = 0 ;
28976 PyObject * obj2 = 0 ;
28977 PyObject * obj3 = 0 ;
28978 char *kwnames[] = {
28979 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28980 };
28981
28982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28984 if (SWIG_arg_fail(1)) SWIG_fail;
28985 {
28986 arg2 = (int)(SWIG_As_int(obj1));
28987 if (SWIG_arg_fail(2)) SWIG_fail;
28988 }
28989 {
28990 arg3 = (int)(SWIG_As_int(obj2));
28991 if (SWIG_arg_fail(3)) SWIG_fail;
28992 }
28993 {
28994 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28995 if (SWIG_arg_fail(4)) SWIG_fail;
28996 }
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29000
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 resultobj = SWIG_From_int((result));
29005 return resultobj;
29006 fail:
29007 return NULL;
29008 }
29009
29010
29011 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29012 PyObject *resultobj;
29013 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29014 PyObject * obj0 = 0 ;
29015 char *kwnames[] = {
29016 (char *) "self", NULL
29017 };
29018
29019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29021 if (SWIG_arg_fail(1)) SWIG_fail;
29022 {
29023 PyThreadState* __tstate = wxPyBeginAllowThreads();
29024 (arg1)->base_OnLeave();
29025
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 Py_INCREF(Py_None); resultobj = Py_None;
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29037 PyObject *resultobj;
29038 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29039 int arg2 ;
29040 int arg3 ;
29041 bool result;
29042 PyObject * obj0 = 0 ;
29043 PyObject * obj1 = 0 ;
29044 PyObject * obj2 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "x",(char *) "y", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = (int)(SWIG_As_int(obj1));
29054 if (SWIG_arg_fail(2)) SWIG_fail;
29055 }
29056 {
29057 arg3 = (int)(SWIG_As_int(obj2));
29058 if (SWIG_arg_fail(3)) SWIG_fail;
29059 }
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29063
29064 wxPyEndAllowThreads(__tstate);
29065 if (PyErr_Occurred()) SWIG_fail;
29066 }
29067 {
29068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29069 }
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29079 bool result;
29080 PyObject * obj0 = 0 ;
29081 char *kwnames[] = {
29082 (char *) "self", NULL
29083 };
29084
29085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29087 if (SWIG_arg_fail(1)) SWIG_fail;
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = (bool)(arg1)->GetData();
29091
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 {
29096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29097 }
29098 return resultobj;
29099 fail:
29100 return NULL;
29101 }
29102
29103
29104 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29105 PyObject *resultobj;
29106 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29107 wxDragResult arg2 ;
29108 PyObject * obj0 = 0 ;
29109 PyObject * obj1 = 0 ;
29110 char *kwnames[] = {
29111 (char *) "self",(char *) "action", NULL
29112 };
29113
29114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29116 if (SWIG_arg_fail(1)) SWIG_fail;
29117 {
29118 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29119 if (SWIG_arg_fail(2)) SWIG_fail;
29120 }
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 (arg1)->SetDefaultAction((wxDragResult )arg2);
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 Py_INCREF(Py_None); resultobj = Py_None;
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29136 PyObject *resultobj;
29137 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29138 wxDragResult result;
29139 PyObject * obj0 = 0 ;
29140 char *kwnames[] = {
29141 (char *) "self", NULL
29142 };
29143
29144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29146 if (SWIG_arg_fail(1)) SWIG_fail;
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 result = (wxDragResult)(arg1)->GetDefaultAction();
29150
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_From_int((result));
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29162 PyObject *obj;
29163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29164 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29165 Py_INCREF(obj);
29166 return Py_BuildValue((char *)"");
29167 }
29168 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj;
29170 wxPyTextDropTarget *result;
29171 char *kwnames[] = {
29172 NULL
29173 };
29174
29175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29179
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29191 PyObject *resultobj;
29192 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29193 PyObject *arg2 = (PyObject *) 0 ;
29194 PyObject *arg3 = (PyObject *) 0 ;
29195 PyObject * obj0 = 0 ;
29196 PyObject * obj1 = 0 ;
29197 PyObject * obj2 = 0 ;
29198 char *kwnames[] = {
29199 (char *) "self",(char *) "self",(char *) "_class", NULL
29200 };
29201
29202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29204 if (SWIG_arg_fail(1)) SWIG_fail;
29205 arg2 = obj1;
29206 arg3 = obj2;
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 (arg1)->_setCallbackInfo(arg2,arg3);
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 Py_INCREF(Py_None); resultobj = Py_None;
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29222 PyObject *resultobj;
29223 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29224 int arg2 ;
29225 int arg3 ;
29226 wxDragResult arg4 ;
29227 wxDragResult result;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 PyObject * obj2 = 0 ;
29231 PyObject * obj3 = 0 ;
29232 char *kwnames[] = {
29233 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29234 };
29235
29236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29238 if (SWIG_arg_fail(1)) SWIG_fail;
29239 {
29240 arg2 = (int)(SWIG_As_int(obj1));
29241 if (SWIG_arg_fail(2)) SWIG_fail;
29242 }
29243 {
29244 arg3 = (int)(SWIG_As_int(obj2));
29245 if (SWIG_arg_fail(3)) SWIG_fail;
29246 }
29247 {
29248 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29249 if (SWIG_arg_fail(4)) SWIG_fail;
29250 }
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29254
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 resultobj = SWIG_From_int((result));
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29266 PyObject *resultobj;
29267 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29268 int arg2 ;
29269 int arg3 ;
29270 wxDragResult arg4 ;
29271 wxDragResult result;
29272 PyObject * obj0 = 0 ;
29273 PyObject * obj1 = 0 ;
29274 PyObject * obj2 = 0 ;
29275 PyObject * obj3 = 0 ;
29276 char *kwnames[] = {
29277 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29278 };
29279
29280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29282 if (SWIG_arg_fail(1)) SWIG_fail;
29283 {
29284 arg2 = (int)(SWIG_As_int(obj1));
29285 if (SWIG_arg_fail(2)) SWIG_fail;
29286 }
29287 {
29288 arg3 = (int)(SWIG_As_int(obj2));
29289 if (SWIG_arg_fail(3)) SWIG_fail;
29290 }
29291 {
29292 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29293 if (SWIG_arg_fail(4)) SWIG_fail;
29294 }
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29298
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_From_int((result));
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj;
29311 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29312 PyObject * obj0 = 0 ;
29313 char *kwnames[] = {
29314 (char *) "self", NULL
29315 };
29316
29317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29319 if (SWIG_arg_fail(1)) SWIG_fail;
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 (arg1)->base_OnLeave();
29323
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 Py_INCREF(Py_None); resultobj = Py_None;
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29335 PyObject *resultobj;
29336 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29337 int arg2 ;
29338 int arg3 ;
29339 bool result;
29340 PyObject * obj0 = 0 ;
29341 PyObject * obj1 = 0 ;
29342 PyObject * obj2 = 0 ;
29343 char *kwnames[] = {
29344 (char *) "self",(char *) "x",(char *) "y", NULL
29345 };
29346
29347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29349 if (SWIG_arg_fail(1)) SWIG_fail;
29350 {
29351 arg2 = (int)(SWIG_As_int(obj1));
29352 if (SWIG_arg_fail(2)) SWIG_fail;
29353 }
29354 {
29355 arg3 = (int)(SWIG_As_int(obj2));
29356 if (SWIG_arg_fail(3)) SWIG_fail;
29357 }
29358 {
29359 PyThreadState* __tstate = wxPyBeginAllowThreads();
29360 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29361
29362 wxPyEndAllowThreads(__tstate);
29363 if (PyErr_Occurred()) SWIG_fail;
29364 }
29365 {
29366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29367 }
29368 return resultobj;
29369 fail:
29370 return NULL;
29371 }
29372
29373
29374 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29375 PyObject *resultobj;
29376 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29377 int arg2 ;
29378 int arg3 ;
29379 wxDragResult arg4 ;
29380 wxDragResult result;
29381 PyObject * obj0 = 0 ;
29382 PyObject * obj1 = 0 ;
29383 PyObject * obj2 = 0 ;
29384 PyObject * obj3 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 arg2 = (int)(SWIG_As_int(obj1));
29394 if (SWIG_arg_fail(2)) SWIG_fail;
29395 }
29396 {
29397 arg3 = (int)(SWIG_As_int(obj2));
29398 if (SWIG_arg_fail(3)) SWIG_fail;
29399 }
29400 {
29401 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29402 if (SWIG_arg_fail(4)) SWIG_fail;
29403 }
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 resultobj = SWIG_From_int((result));
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29419 PyObject *obj;
29420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29421 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29422 Py_INCREF(obj);
29423 return Py_BuildValue((char *)"");
29424 }
29425 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29426 PyObject *resultobj;
29427 wxPyFileDropTarget *result;
29428 char *kwnames[] = {
29429 NULL
29430 };
29431
29432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29433 {
29434 PyThreadState* __tstate = wxPyBeginAllowThreads();
29435 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29436
29437 wxPyEndAllowThreads(__tstate);
29438 if (PyErr_Occurred()) SWIG_fail;
29439 }
29440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29441 return resultobj;
29442 fail:
29443 return NULL;
29444 }
29445
29446
29447 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29448 PyObject *resultobj;
29449 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29450 PyObject *arg2 = (PyObject *) 0 ;
29451 PyObject *arg3 = (PyObject *) 0 ;
29452 PyObject * obj0 = 0 ;
29453 PyObject * obj1 = 0 ;
29454 PyObject * obj2 = 0 ;
29455 char *kwnames[] = {
29456 (char *) "self",(char *) "self",(char *) "_class", NULL
29457 };
29458
29459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29461 if (SWIG_arg_fail(1)) SWIG_fail;
29462 arg2 = obj1;
29463 arg3 = obj2;
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 (arg1)->_setCallbackInfo(arg2,arg3);
29467
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 Py_INCREF(Py_None); resultobj = Py_None;
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj;
29480 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29481 int arg2 ;
29482 int arg3 ;
29483 wxDragResult arg4 ;
29484 wxDragResult result;
29485 PyObject * obj0 = 0 ;
29486 PyObject * obj1 = 0 ;
29487 PyObject * obj2 = 0 ;
29488 PyObject * obj3 = 0 ;
29489 char *kwnames[] = {
29490 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29491 };
29492
29493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29495 if (SWIG_arg_fail(1)) SWIG_fail;
29496 {
29497 arg2 = (int)(SWIG_As_int(obj1));
29498 if (SWIG_arg_fail(2)) SWIG_fail;
29499 }
29500 {
29501 arg3 = (int)(SWIG_As_int(obj2));
29502 if (SWIG_arg_fail(3)) SWIG_fail;
29503 }
29504 {
29505 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29506 if (SWIG_arg_fail(4)) SWIG_fail;
29507 }
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29511
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 resultobj = SWIG_From_int((result));
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj;
29524 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29525 int arg2 ;
29526 int arg3 ;
29527 wxDragResult arg4 ;
29528 wxDragResult result;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 PyObject * obj2 = 0 ;
29532 PyObject * obj3 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 arg2 = (int)(SWIG_As_int(obj1));
29542 if (SWIG_arg_fail(2)) SWIG_fail;
29543 }
29544 {
29545 arg3 = (int)(SWIG_As_int(obj2));
29546 if (SWIG_arg_fail(3)) SWIG_fail;
29547 }
29548 {
29549 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29550 if (SWIG_arg_fail(4)) SWIG_fail;
29551 }
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29555
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 resultobj = SWIG_From_int((result));
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29567 PyObject *resultobj;
29568 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29569 PyObject * obj0 = 0 ;
29570 char *kwnames[] = {
29571 (char *) "self", NULL
29572 };
29573
29574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29576 if (SWIG_arg_fail(1)) SWIG_fail;
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 (arg1)->base_OnLeave();
29580
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 Py_INCREF(Py_None); resultobj = Py_None;
29585 return resultobj;
29586 fail:
29587 return NULL;
29588 }
29589
29590
29591 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29592 PyObject *resultobj;
29593 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29594 int arg2 ;
29595 int arg3 ;
29596 bool result;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 PyObject * obj2 = 0 ;
29600 char *kwnames[] = {
29601 (char *) "self",(char *) "x",(char *) "y", NULL
29602 };
29603
29604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29606 if (SWIG_arg_fail(1)) SWIG_fail;
29607 {
29608 arg2 = (int)(SWIG_As_int(obj1));
29609 if (SWIG_arg_fail(2)) SWIG_fail;
29610 }
29611 {
29612 arg3 = (int)(SWIG_As_int(obj2));
29613 if (SWIG_arg_fail(3)) SWIG_fail;
29614 }
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29618
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 {
29623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29624 }
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj;
29633 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29634 int arg2 ;
29635 int arg3 ;
29636 wxDragResult arg4 ;
29637 wxDragResult result;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 PyObject * obj2 = 0 ;
29641 PyObject * obj3 = 0 ;
29642 char *kwnames[] = {
29643 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29644 };
29645
29646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29648 if (SWIG_arg_fail(1)) SWIG_fail;
29649 {
29650 arg2 = (int)(SWIG_As_int(obj1));
29651 if (SWIG_arg_fail(2)) SWIG_fail;
29652 }
29653 {
29654 arg3 = (int)(SWIG_As_int(obj2));
29655 if (SWIG_arg_fail(3)) SWIG_fail;
29656 }
29657 {
29658 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29659 if (SWIG_arg_fail(4)) SWIG_fail;
29660 }
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29664
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 resultobj = SWIG_From_int((result));
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29676 PyObject *obj;
29677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29678 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29679 Py_INCREF(obj);
29680 return Py_BuildValue((char *)"");
29681 }
29682 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29683 PyObject *resultobj;
29684 wxClipboard *result;
29685 char *kwnames[] = {
29686 NULL
29687 };
29688
29689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (wxClipboard *)new wxClipboard();
29693
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj;
29706 wxClipboard *arg1 = (wxClipboard *) 0 ;
29707 PyObject * obj0 = 0 ;
29708 char *kwnames[] = {
29709 (char *) "self", NULL
29710 };
29711
29712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29714 if (SWIG_arg_fail(1)) SWIG_fail;
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 delete arg1;
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 Py_INCREF(Py_None); resultobj = Py_None;
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj;
29731 wxClipboard *arg1 = (wxClipboard *) 0 ;
29732 bool result;
29733 PyObject * obj0 = 0 ;
29734 char *kwnames[] = {
29735 (char *) "self", NULL
29736 };
29737
29738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29740 if (SWIG_arg_fail(1)) SWIG_fail;
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = (bool)(arg1)->Open();
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 {
29749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29750 }
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj;
29759 wxClipboard *arg1 = (wxClipboard *) 0 ;
29760 PyObject * obj0 = 0 ;
29761 char *kwnames[] = {
29762 (char *) "self", NULL
29763 };
29764
29765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29767 if (SWIG_arg_fail(1)) SWIG_fail;
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 (arg1)->Close();
29771
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 Py_INCREF(Py_None); resultobj = Py_None;
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxClipboard *arg1 = (wxClipboard *) 0 ;
29785 bool result;
29786 PyObject * obj0 = 0 ;
29787 char *kwnames[] = {
29788 (char *) "self", NULL
29789 };
29790
29791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29793 if (SWIG_arg_fail(1)) SWIG_fail;
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29797
29798 wxPyEndAllowThreads(__tstate);
29799 if (PyErr_Occurred()) SWIG_fail;
29800 }
29801 {
29802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29803 }
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29811 PyObject *resultobj;
29812 wxClipboard *arg1 = (wxClipboard *) 0 ;
29813 wxDataObject *arg2 = (wxDataObject *) 0 ;
29814 bool result;
29815 PyObject * obj0 = 0 ;
29816 PyObject * obj1 = 0 ;
29817 char *kwnames[] = {
29818 (char *) "self",(char *) "data", NULL
29819 };
29820
29821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29823 if (SWIG_arg_fail(1)) SWIG_fail;
29824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29825 if (SWIG_arg_fail(2)) SWIG_fail;
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (bool)(arg1)->AddData(arg2);
29829
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29835 }
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29843 PyObject *resultobj;
29844 wxClipboard *arg1 = (wxClipboard *) 0 ;
29845 wxDataObject *arg2 = (wxDataObject *) 0 ;
29846 bool result;
29847 PyObject * obj0 = 0 ;
29848 PyObject * obj1 = 0 ;
29849 char *kwnames[] = {
29850 (char *) "self",(char *) "data", NULL
29851 };
29852
29853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29855 if (SWIG_arg_fail(1)) SWIG_fail;
29856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29857 if (SWIG_arg_fail(2)) SWIG_fail;
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 result = (bool)(arg1)->SetData(arg2);
29861
29862 wxPyEndAllowThreads(__tstate);
29863 if (PyErr_Occurred()) SWIG_fail;
29864 }
29865 {
29866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29867 }
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj;
29876 wxClipboard *arg1 = (wxClipboard *) 0 ;
29877 wxDataFormat *arg2 = 0 ;
29878 bool result;
29879 PyObject * obj0 = 0 ;
29880 PyObject * obj1 = 0 ;
29881 char *kwnames[] = {
29882 (char *) "self",(char *) "format", NULL
29883 };
29884
29885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29887 if (SWIG_arg_fail(1)) SWIG_fail;
29888 {
29889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29890 if (SWIG_arg_fail(2)) SWIG_fail;
29891 if (arg2 == NULL) {
29892 SWIG_null_ref("wxDataFormat");
29893 }
29894 if (SWIG_arg_fail(2)) SWIG_fail;
29895 }
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29899
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 {
29904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29905 }
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj;
29914 wxClipboard *arg1 = (wxClipboard *) 0 ;
29915 wxDataObject *arg2 = 0 ;
29916 bool result;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 char *kwnames[] = {
29920 (char *) "self",(char *) "data", NULL
29921 };
29922
29923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29925 if (SWIG_arg_fail(1)) SWIG_fail;
29926 {
29927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29928 if (SWIG_arg_fail(2)) SWIG_fail;
29929 if (arg2 == NULL) {
29930 SWIG_null_ref("wxDataObject");
29931 }
29932 if (SWIG_arg_fail(2)) SWIG_fail;
29933 }
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 result = (bool)(arg1)->GetData(*arg2);
29937
29938 wxPyEndAllowThreads(__tstate);
29939 if (PyErr_Occurred()) SWIG_fail;
29940 }
29941 {
29942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29943 }
29944 return resultobj;
29945 fail:
29946 return NULL;
29947 }
29948
29949
29950 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29951 PyObject *resultobj;
29952 wxClipboard *arg1 = (wxClipboard *) 0 ;
29953 PyObject * obj0 = 0 ;
29954 char *kwnames[] = {
29955 (char *) "self", NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29960 if (SWIG_arg_fail(1)) SWIG_fail;
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 (arg1)->Clear();
29964
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 Py_INCREF(Py_None); resultobj = Py_None;
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj;
29977 wxClipboard *arg1 = (wxClipboard *) 0 ;
29978 bool result;
29979 PyObject * obj0 = 0 ;
29980 char *kwnames[] = {
29981 (char *) "self", NULL
29982 };
29983
29984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29986 if (SWIG_arg_fail(1)) SWIG_fail;
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 result = (bool)(arg1)->Flush();
29990
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 {
29995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29996 }
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj;
30005 wxClipboard *arg1 = (wxClipboard *) 0 ;
30006 bool arg2 = (bool) true ;
30007 PyObject * obj0 = 0 ;
30008 PyObject * obj1 = 0 ;
30009 char *kwnames[] = {
30010 (char *) "self",(char *) "primary", NULL
30011 };
30012
30013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30015 if (SWIG_arg_fail(1)) SWIG_fail;
30016 if (obj1) {
30017 {
30018 arg2 = (bool)(SWIG_As_bool(obj1));
30019 if (SWIG_arg_fail(2)) SWIG_fail;
30020 }
30021 }
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 (arg1)->UsePrimarySelection(arg2);
30025
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 Py_INCREF(Py_None); resultobj = Py_None;
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj;
30038 wxClipboard *result;
30039 char *kwnames[] = {
30040 NULL
30041 };
30042
30043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (wxClipboard *)wxClipboard::Get();
30047
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30059 PyObject *obj;
30060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30061 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30062 Py_INCREF(obj);
30063 return Py_BuildValue((char *)"");
30064 }
30065 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30066 PyObject *resultobj;
30067 wxClipboard *arg1 = (wxClipboard *) NULL ;
30068 wxClipboardLocker *result;
30069 PyObject * obj0 = 0 ;
30070 char *kwnames[] = {
30071 (char *) "clipboard", NULL
30072 };
30073
30074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30075 if (obj0) {
30076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30077 if (SWIG_arg_fail(1)) SWIG_fail;
30078 }
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30082
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30094 PyObject *resultobj;
30095 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30096 PyObject * obj0 = 0 ;
30097 char *kwnames[] = {
30098 (char *) "self", NULL
30099 };
30100
30101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30103 if (SWIG_arg_fail(1)) SWIG_fail;
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 delete arg1;
30107
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 Py_INCREF(Py_None); resultobj = Py_None;
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj;
30120 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30121 bool result;
30122 PyObject * obj0 = 0 ;
30123 char *kwnames[] = {
30124 (char *) "self", NULL
30125 };
30126
30127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30129 if (SWIG_arg_fail(1)) SWIG_fail;
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (bool)wxClipboardLocker___nonzero__(arg1);
30133
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 {
30138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30139 }
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30147 PyObject *obj;
30148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30149 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30150 Py_INCREF(obj);
30151 return Py_BuildValue((char *)"");
30152 }
30153 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30154 PyObject *resultobj;
30155 int arg1 = (int) 0 ;
30156 int arg2 = (int) 0 ;
30157 int arg3 = (int) 0 ;
30158 int arg4 = (int) 0 ;
30159 wxVideoMode *result;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162 PyObject * obj2 = 0 ;
30163 PyObject * obj3 = 0 ;
30164 char *kwnames[] = {
30165 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30166 };
30167
30168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30169 if (obj0) {
30170 {
30171 arg1 = (int)(SWIG_As_int(obj0));
30172 if (SWIG_arg_fail(1)) SWIG_fail;
30173 }
30174 }
30175 if (obj1) {
30176 {
30177 arg2 = (int)(SWIG_As_int(obj1));
30178 if (SWIG_arg_fail(2)) SWIG_fail;
30179 }
30180 }
30181 if (obj2) {
30182 {
30183 arg3 = (int)(SWIG_As_int(obj2));
30184 if (SWIG_arg_fail(3)) SWIG_fail;
30185 }
30186 }
30187 if (obj3) {
30188 {
30189 arg4 = (int)(SWIG_As_int(obj3));
30190 if (SWIG_arg_fail(4)) SWIG_fail;
30191 }
30192 }
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30196
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj;
30209 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30210 PyObject * obj0 = 0 ;
30211 char *kwnames[] = {
30212 (char *) "self", NULL
30213 };
30214
30215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30217 if (SWIG_arg_fail(1)) SWIG_fail;
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 delete arg1;
30221
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 Py_INCREF(Py_None); resultobj = Py_None;
30226 return resultobj;
30227 fail:
30228 return NULL;
30229 }
30230
30231
30232 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30233 PyObject *resultobj;
30234 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30235 wxVideoMode *arg2 = 0 ;
30236 bool result;
30237 PyObject * obj0 = 0 ;
30238 PyObject * obj1 = 0 ;
30239 char *kwnames[] = {
30240 (char *) "self",(char *) "other", NULL
30241 };
30242
30243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30245 if (SWIG_arg_fail(1)) SWIG_fail;
30246 {
30247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30248 if (SWIG_arg_fail(2)) SWIG_fail;
30249 if (arg2 == NULL) {
30250 SWIG_null_ref("wxVideoMode");
30251 }
30252 if (SWIG_arg_fail(2)) SWIG_fail;
30253 }
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30257
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 {
30262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30263 }
30264 return resultobj;
30265 fail:
30266 return NULL;
30267 }
30268
30269
30270 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30271 PyObject *resultobj;
30272 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30273 int result;
30274 PyObject * obj0 = 0 ;
30275 char *kwnames[] = {
30276 (char *) "self", NULL
30277 };
30278
30279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30281 if (SWIG_arg_fail(1)) SWIG_fail;
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30285
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 {
30290 resultobj = SWIG_From_int((int)(result));
30291 }
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj;
30300 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30301 int result;
30302 PyObject * obj0 = 0 ;
30303 char *kwnames[] = {
30304 (char *) "self", NULL
30305 };
30306
30307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30309 if (SWIG_arg_fail(1)) SWIG_fail;
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30313
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 {
30318 resultobj = SWIG_From_int((int)(result));
30319 }
30320 return resultobj;
30321 fail:
30322 return NULL;
30323 }
30324
30325
30326 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30327 PyObject *resultobj;
30328 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30329 int result;
30330 PyObject * obj0 = 0 ;
30331 char *kwnames[] = {
30332 (char *) "self", NULL
30333 };
30334
30335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30337 if (SWIG_arg_fail(1)) SWIG_fail;
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30341
30342 wxPyEndAllowThreads(__tstate);
30343 if (PyErr_Occurred()) SWIG_fail;
30344 }
30345 {
30346 resultobj = SWIG_From_int((int)(result));
30347 }
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30355 PyObject *resultobj;
30356 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30357 bool result;
30358 PyObject * obj0 = 0 ;
30359 char *kwnames[] = {
30360 (char *) "self", NULL
30361 };
30362
30363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30365 if (SWIG_arg_fail(1)) SWIG_fail;
30366 {
30367 PyThreadState* __tstate = wxPyBeginAllowThreads();
30368 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30369
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 {
30374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30375 }
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30383 PyObject *resultobj;
30384 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30385 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30386 bool result;
30387 PyObject * obj0 = 0 ;
30388 PyObject * obj1 = 0 ;
30389 char *kwnames[] = {
30390 (char *) "self",(char *) "other", NULL
30391 };
30392
30393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(2)) SWIG_fail;
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30401
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 {
30406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30407 }
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30415 PyObject *resultobj;
30416 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30417 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30418 bool result;
30419 PyObject * obj0 = 0 ;
30420 PyObject * obj1 = 0 ;
30421 char *kwnames[] = {
30422 (char *) "self",(char *) "other", NULL
30423 };
30424
30425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30427 if (SWIG_arg_fail(1)) SWIG_fail;
30428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30429 if (SWIG_arg_fail(2)) SWIG_fail;
30430 {
30431 PyThreadState* __tstate = wxPyBeginAllowThreads();
30432 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30433
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 {
30438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30439 }
30440 return resultobj;
30441 fail:
30442 return NULL;
30443 }
30444
30445
30446 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30447 PyObject *resultobj;
30448 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30449 int arg2 ;
30450 PyObject * obj0 = 0 ;
30451 PyObject * obj1 = 0 ;
30452 char *kwnames[] = {
30453 (char *) "self",(char *) "w", NULL
30454 };
30455
30456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30458 if (SWIG_arg_fail(1)) SWIG_fail;
30459 {
30460 arg2 = (int)(SWIG_As_int(obj1));
30461 if (SWIG_arg_fail(2)) SWIG_fail;
30462 }
30463 if (arg1) (arg1)->w = arg2;
30464
30465 Py_INCREF(Py_None); resultobj = Py_None;
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj;
30474 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30475 int result;
30476 PyObject * obj0 = 0 ;
30477 char *kwnames[] = {
30478 (char *) "self", NULL
30479 };
30480
30481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30483 if (SWIG_arg_fail(1)) SWIG_fail;
30484 result = (int) ((arg1)->w);
30485
30486 {
30487 resultobj = SWIG_From_int((int)(result));
30488 }
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj;
30497 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30498 int arg2 ;
30499 PyObject * obj0 = 0 ;
30500 PyObject * obj1 = 0 ;
30501 char *kwnames[] = {
30502 (char *) "self",(char *) "h", NULL
30503 };
30504
30505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30507 if (SWIG_arg_fail(1)) SWIG_fail;
30508 {
30509 arg2 = (int)(SWIG_As_int(obj1));
30510 if (SWIG_arg_fail(2)) SWIG_fail;
30511 }
30512 if (arg1) (arg1)->h = arg2;
30513
30514 Py_INCREF(Py_None); resultobj = Py_None;
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj;
30523 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30524 int result;
30525 PyObject * obj0 = 0 ;
30526 char *kwnames[] = {
30527 (char *) "self", NULL
30528 };
30529
30530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30532 if (SWIG_arg_fail(1)) SWIG_fail;
30533 result = (int) ((arg1)->h);
30534
30535 {
30536 resultobj = SWIG_From_int((int)(result));
30537 }
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj;
30546 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30547 int arg2 ;
30548 PyObject * obj0 = 0 ;
30549 PyObject * obj1 = 0 ;
30550 char *kwnames[] = {
30551 (char *) "self",(char *) "bpp", NULL
30552 };
30553
30554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30556 if (SWIG_arg_fail(1)) SWIG_fail;
30557 {
30558 arg2 = (int)(SWIG_As_int(obj1));
30559 if (SWIG_arg_fail(2)) SWIG_fail;
30560 }
30561 if (arg1) (arg1)->bpp = arg2;
30562
30563 Py_INCREF(Py_None); resultobj = Py_None;
30564 return resultobj;
30565 fail:
30566 return NULL;
30567 }
30568
30569
30570 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj;
30572 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30573 int result;
30574 PyObject * obj0 = 0 ;
30575 char *kwnames[] = {
30576 (char *) "self", NULL
30577 };
30578
30579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30581 if (SWIG_arg_fail(1)) SWIG_fail;
30582 result = (int) ((arg1)->bpp);
30583
30584 {
30585 resultobj = SWIG_From_int((int)(result));
30586 }
30587 return resultobj;
30588 fail:
30589 return NULL;
30590 }
30591
30592
30593 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30594 PyObject *resultobj;
30595 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30596 int arg2 ;
30597 PyObject * obj0 = 0 ;
30598 PyObject * obj1 = 0 ;
30599 char *kwnames[] = {
30600 (char *) "self",(char *) "refresh", NULL
30601 };
30602
30603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30605 if (SWIG_arg_fail(1)) SWIG_fail;
30606 {
30607 arg2 = (int)(SWIG_As_int(obj1));
30608 if (SWIG_arg_fail(2)) SWIG_fail;
30609 }
30610 if (arg1) (arg1)->refresh = arg2;
30611
30612 Py_INCREF(Py_None); resultobj = Py_None;
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30620 PyObject *resultobj;
30621 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30622 int result;
30623 PyObject * obj0 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 result = (int) ((arg1)->refresh);
30632
30633 {
30634 resultobj = SWIG_From_int((int)(result));
30635 }
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30643 PyObject *obj;
30644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30645 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30646 Py_INCREF(obj);
30647 return Py_BuildValue((char *)"");
30648 }
30649 static int _wrap_DefaultVideoMode_set(PyObject *) {
30650 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30651 return 1;
30652 }
30653
30654
30655 static PyObject *_wrap_DefaultVideoMode_get(void) {
30656 PyObject *pyobj;
30657
30658 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30659 return pyobj;
30660 }
30661
30662
30663 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30664 PyObject *resultobj;
30665 size_t arg1 = (size_t) 0 ;
30666 wxDisplay *result;
30667 PyObject * obj0 = 0 ;
30668 char *kwnames[] = {
30669 (char *) "index", NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30673 if (obj0) {
30674 {
30675 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30676 if (SWIG_arg_fail(1)) SWIG_fail;
30677 }
30678 }
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = (wxDisplay *)new wxDisplay(arg1);
30682
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj;
30695 wxDisplay *arg1 = (wxDisplay *) 0 ;
30696 PyObject * obj0 = 0 ;
30697 char *kwnames[] = {
30698 (char *) "self", NULL
30699 };
30700
30701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30703 if (SWIG_arg_fail(1)) SWIG_fail;
30704 {
30705 PyThreadState* __tstate = wxPyBeginAllowThreads();
30706 delete arg1;
30707
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 Py_INCREF(Py_None); resultobj = Py_None;
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30719 PyObject *resultobj;
30720 size_t result;
30721 char *kwnames[] = {
30722 NULL
30723 };
30724
30725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (size_t)wxDisplay::GetCount();
30729
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30743 PyObject *resultobj;
30744 wxPoint *arg1 = 0 ;
30745 int result;
30746 wxPoint temp1 ;
30747 PyObject * obj0 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "pt", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30753 {
30754 arg1 = &temp1;
30755 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 {
30765 resultobj = SWIG_From_int((int)(result));
30766 }
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30774 PyObject *resultobj;
30775 wxWindow *arg1 = (wxWindow *) 0 ;
30776 int result;
30777 PyObject * obj0 = 0 ;
30778 char *kwnames[] = {
30779 (char *) "window", NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30784 if (SWIG_arg_fail(1)) SWIG_fail;
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = (int)Display_GetFromWindow(arg1);
30788
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = SWIG_From_int((int)(result));
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj;
30803 wxDisplay *arg1 = (wxDisplay *) 0 ;
30804 bool result;
30805 PyObject * obj0 = 0 ;
30806 char *kwnames[] = {
30807 (char *) "self", NULL
30808 };
30809
30810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30812 if (SWIG_arg_fail(1)) SWIG_fail;
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 result = (bool)((wxDisplay const *)arg1)->IsOk();
30816
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 {
30821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30822 }
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30830 PyObject *resultobj;
30831 wxDisplay *arg1 = (wxDisplay *) 0 ;
30832 wxRect result;
30833 PyObject * obj0 = 0 ;
30834 char *kwnames[] = {
30835 (char *) "self", NULL
30836 };
30837
30838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30840 if (SWIG_arg_fail(1)) SWIG_fail;
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 result = ((wxDisplay const *)arg1)->GetGeometry();
30844
30845 wxPyEndAllowThreads(__tstate);
30846 if (PyErr_Occurred()) SWIG_fail;
30847 }
30848 {
30849 wxRect * resultptr;
30850 resultptr = new wxRect((wxRect &)(result));
30851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30852 }
30853 return resultobj;
30854 fail:
30855 return NULL;
30856 }
30857
30858
30859 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30860 PyObject *resultobj;
30861 wxDisplay *arg1 = (wxDisplay *) 0 ;
30862 wxString result;
30863 PyObject * obj0 = 0 ;
30864 char *kwnames[] = {
30865 (char *) "self", NULL
30866 };
30867
30868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30870 if (SWIG_arg_fail(1)) SWIG_fail;
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = ((wxDisplay const *)arg1)->GetName();
30874
30875 wxPyEndAllowThreads(__tstate);
30876 if (PyErr_Occurred()) SWIG_fail;
30877 }
30878 {
30879 #if wxUSE_UNICODE
30880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30881 #else
30882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30883 #endif
30884 }
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj;
30893 wxDisplay *arg1 = (wxDisplay *) 0 ;
30894 bool result;
30895 PyObject * obj0 = 0 ;
30896 char *kwnames[] = {
30897 (char *) "self", NULL
30898 };
30899
30900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30902 if (SWIG_arg_fail(1)) SWIG_fail;
30903 {
30904 PyThreadState* __tstate = wxPyBeginAllowThreads();
30905 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30906
30907 wxPyEndAllowThreads(__tstate);
30908 if (PyErr_Occurred()) SWIG_fail;
30909 }
30910 {
30911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30912 }
30913 return resultobj;
30914 fail:
30915 return NULL;
30916 }
30917
30918
30919 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30920 PyObject *resultobj;
30921 wxDisplay *arg1 = (wxDisplay *) 0 ;
30922 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30923 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30924 PyObject *result;
30925 PyObject * obj0 = 0 ;
30926 PyObject * obj1 = 0 ;
30927 char *kwnames[] = {
30928 (char *) "self",(char *) "mode", NULL
30929 };
30930
30931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30933 if (SWIG_arg_fail(1)) SWIG_fail;
30934 if (obj1) {
30935 {
30936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30937 if (SWIG_arg_fail(2)) SWIG_fail;
30938 if (arg2 == NULL) {
30939 SWIG_null_ref("wxVideoMode");
30940 }
30941 if (SWIG_arg_fail(2)) SWIG_fail;
30942 }
30943 }
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30947
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 resultobj = result;
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj;
30960 wxDisplay *arg1 = (wxDisplay *) 0 ;
30961 wxVideoMode result;
30962 PyObject * obj0 = 0 ;
30963 char *kwnames[] = {
30964 (char *) "self", NULL
30965 };
30966
30967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(1)) SWIG_fail;
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30973
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 {
30978 wxVideoMode * resultptr;
30979 resultptr = new wxVideoMode((wxVideoMode &)(result));
30980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30981 }
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj;
30990 wxDisplay *arg1 = (wxDisplay *) 0 ;
30991 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30992 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30993 bool result;
30994 PyObject * obj0 = 0 ;
30995 PyObject * obj1 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self",(char *) "mode", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 if (obj1) {
31004 {
31005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31006 if (SWIG_arg_fail(2)) SWIG_fail;
31007 if (arg2 == NULL) {
31008 SWIG_null_ref("wxVideoMode");
31009 }
31010 if (SWIG_arg_fail(2)) SWIG_fail;
31011 }
31012 }
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31016
31017 wxPyEndAllowThreads(__tstate);
31018 if (PyErr_Occurred()) SWIG_fail;
31019 }
31020 {
31021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31022 }
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31030 PyObject *resultobj;
31031 wxDisplay *arg1 = (wxDisplay *) 0 ;
31032 PyObject * obj0 = 0 ;
31033 char *kwnames[] = {
31034 (char *) "self", NULL
31035 };
31036
31037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31039 if (SWIG_arg_fail(1)) SWIG_fail;
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 (arg1)->ResetMode();
31043
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 Py_INCREF(Py_None); resultobj = Py_None;
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31055 PyObject *obj;
31056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31057 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31058 Py_INCREF(obj);
31059 return Py_BuildValue((char *)"");
31060 }
31061 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj;
31063 wxStandardPaths *result;
31064 char *kwnames[] = {
31065 NULL
31066 };
31067
31068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 result = (wxStandardPaths *)StandardPaths_Get();
31072
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj;
31085 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31086 wxString result;
31087 PyObject * obj0 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31098
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 {
31103 #if wxUSE_UNICODE
31104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31105 #else
31106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31107 #endif
31108 }
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj;
31117 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31118 wxString result;
31119 PyObject * obj0 = 0 ;
31120 char *kwnames[] = {
31121 (char *) "self", NULL
31122 };
31123
31124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31126 if (SWIG_arg_fail(1)) SWIG_fail;
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31130
31131 wxPyEndAllowThreads(__tstate);
31132 if (PyErr_Occurred()) SWIG_fail;
31133 }
31134 {
31135 #if wxUSE_UNICODE
31136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31137 #else
31138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31139 #endif
31140 }
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31148 PyObject *resultobj;
31149 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31150 wxString result;
31151 PyObject * obj0 = 0 ;
31152 char *kwnames[] = {
31153 (char *) "self", NULL
31154 };
31155
31156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31158 if (SWIG_arg_fail(1)) SWIG_fail;
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31162
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 {
31167 #if wxUSE_UNICODE
31168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31169 #else
31170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31171 #endif
31172 }
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31180 PyObject *resultobj;
31181 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31182 wxString result;
31183 PyObject * obj0 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31194
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 {
31199 #if wxUSE_UNICODE
31200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31201 #else
31202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31203 #endif
31204 }
31205 return resultobj;
31206 fail:
31207 return NULL;
31208 }
31209
31210
31211 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31212 PyObject *resultobj;
31213 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31214 wxString result;
31215 PyObject * obj0 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "self", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(1)) SWIG_fail;
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 {
31231 #if wxUSE_UNICODE
31232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31233 #else
31234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31235 #endif
31236 }
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj;
31245 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31246 wxString result;
31247 PyObject * obj0 = 0 ;
31248 char *kwnames[] = {
31249 (char *) "self", NULL
31250 };
31251
31252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31254 if (SWIG_arg_fail(1)) SWIG_fail;
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31258
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 {
31263 #if wxUSE_UNICODE
31264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31265 #else
31266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31267 #endif
31268 }
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31276 PyObject *resultobj;
31277 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31278 wxString result;
31279 PyObject * obj0 = 0 ;
31280 char *kwnames[] = {
31281 (char *) "self", NULL
31282 };
31283
31284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31286 if (SWIG_arg_fail(1)) SWIG_fail;
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31290
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 {
31295 #if wxUSE_UNICODE
31296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31297 #else
31298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31299 #endif
31300 }
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31308 PyObject *resultobj;
31309 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31310 wxString *arg2 = 0 ;
31311 bool temp2 = false ;
31312 PyObject * obj0 = 0 ;
31313 PyObject * obj1 = 0 ;
31314 char *kwnames[] = {
31315 (char *) "self",(char *) "prefix", NULL
31316 };
31317
31318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31320 if (SWIG_arg_fail(1)) SWIG_fail;
31321 {
31322 arg2 = wxString_in_helper(obj1);
31323 if (arg2 == NULL) SWIG_fail;
31324 temp2 = true;
31325 }
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31329
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 Py_INCREF(Py_None); resultobj = Py_None;
31334 {
31335 if (temp2)
31336 delete arg2;
31337 }
31338 return resultobj;
31339 fail:
31340 {
31341 if (temp2)
31342 delete arg2;
31343 }
31344 return NULL;
31345 }
31346
31347
31348 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31349 PyObject *resultobj;
31350 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31351 wxString result;
31352 PyObject * obj0 = 0 ;
31353 char *kwnames[] = {
31354 (char *) "self", NULL
31355 };
31356
31357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31359 if (SWIG_arg_fail(1)) SWIG_fail;
31360 {
31361 PyThreadState* __tstate = wxPyBeginAllowThreads();
31362 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31363
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 {
31368 #if wxUSE_UNICODE
31369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31370 #else
31371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31372 #endif
31373 }
31374 return resultobj;
31375 fail:
31376 return NULL;
31377 }
31378
31379
31380 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31381 PyObject *obj;
31382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31383 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31384 Py_INCREF(obj);
31385 return Py_BuildValue((char *)"");
31386 }
31387 static PyMethodDef SwigMethods[] = {
31388 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31395 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31402 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31466 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31474 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31492 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31495 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31498 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31501 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31507 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31521 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31527 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31533 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31536 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31550 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31553 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31554 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31557 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31586 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31588 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31597 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31603 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31617 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31621 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31624 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31641 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31649 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31696 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31714 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31740 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31756 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31770 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31780 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31823 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31826 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31829 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31833 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31926 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31927 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31928 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31929 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31946 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31991 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32025 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32033 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32034 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32039 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32055 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32058 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32061 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32066 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32069 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32073 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32076 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32080 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32081 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32085 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32089 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32091 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32101 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32114 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32122 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32130 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32144 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32148 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32166 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32180 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32191 { NULL, NULL, 0, NULL }
32192 };
32193
32194
32195 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32196
32197 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32198 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32199 }
32200 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32201 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32202 }
32203 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32204 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32205 }
32206 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32207 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32208 }
32209 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32210 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32211 }
32212 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32213 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32214 }
32215 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32216 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32217 }
32218 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32219 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32220 }
32221 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32223 }
32224 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32225 return (void *)((wxEvent *) ((wxPyEvent *) x));
32226 }
32227 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32228 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32229 }
32230 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32231 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32232 }
32233 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32234 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32235 }
32236 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32238 }
32239 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32240 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32241 }
32242 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32243 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32244 }
32245 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32246 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32247 }
32248 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32249 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32250 }
32251 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32252 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32253 }
32254 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32255 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32256 }
32257 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32258 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32259 }
32260 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32261 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32262 }
32263 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32264 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32265 }
32266 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32268 }
32269 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32270 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32271 }
32272 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32273 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32274 }
32275 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32276 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32277 }
32278 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32279 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32280 }
32281 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32282 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32283 }
32284 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32285 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32286 }
32287 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32289 }
32290 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32291 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32292 }
32293 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32294 return (void *)((wxEvent *) ((wxShowEvent *) x));
32295 }
32296 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32297 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32298 }
32299 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32301 }
32302 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32304 }
32305 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32306 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32307 }
32308 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32309 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32310 }
32311 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32312 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32313 }
32314 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32315 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32316 }
32317 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32318 return (void *)((wxConfigBase *) ((wxConfig *) x));
32319 }
32320 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32321 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32322 }
32323 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32324 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32325 }
32326 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32327 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32328 }
32329 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32330 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32331 }
32332 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32333 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32334 }
32335 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32336 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32337 }
32338 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32339 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32340 }
32341 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32343 }
32344 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32345 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32346 }
32347 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32348 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32349 }
32350 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32351 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32352 }
32353 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32354 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32355 }
32356 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32357 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32358 }
32359 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32360 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32361 }
32362 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32363 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32364 }
32365 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32366 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32367 }
32368 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32369 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32370 }
32371 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32372 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32373 }
32374 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32375 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32376 }
32377 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32378 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32379 }
32380 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32381 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32382 }
32383 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32384 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32385 }
32386 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32387 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32388 }
32389 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32390 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32391 }
32392 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32393 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32394 }
32395 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32396 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32397 }
32398 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32399 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32400 }
32401 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32402 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32403 }
32404 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32405 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32406 }
32407 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32408 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32409 }
32410 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32411 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32412 }
32413 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32414 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32415 }
32416 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32417 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32418 }
32419 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32421 }
32422 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32424 }
32425 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) ((wxSizerItem *) x));
32427 }
32428 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32430 }
32431 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32433 }
32434 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32436 }
32437 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32439 }
32440 static void *_p_wxSizerTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) ((wxSizer *) x));
32442 }
32443 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32445 }
32446 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) ((wxFileHistory *) x));
32448 }
32449 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32451 }
32452 static void *_p_wxEventTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) ((wxEvent *) x));
32454 }
32455 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32457 }
32458 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32460 }
32461 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32463 }
32464 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32466 }
32467 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32469 }
32470 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32472 }
32473 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32475 }
32476 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32478 }
32479 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32481 }
32482 static void *_p_wxControlTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32484 }
32485 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32487 }
32488 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32490 }
32491 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) ((wxFSFile *) x));
32493 }
32494 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) ((wxClipboard *) x));
32496 }
32497 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32499 }
32500 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32502 }
32503 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32505 }
32506 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32508 }
32509 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) ((wxToolTip *) x));
32511 }
32512 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) ((wxMenuItem *) x));
32514 }
32515 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32517 }
32518 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32520 }
32521 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32523 }
32524 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32526 }
32527 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32529 }
32530 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32532 }
32533 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32535 }
32536 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32538 }
32539 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32541 }
32542 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32544 }
32545 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32547 }
32548 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32550 }
32551 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32553 }
32554 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32556 }
32557 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32559 }
32560 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32562 }
32563 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32565 }
32566 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32568 }
32569 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32571 }
32572 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) ((wxImageHandler *) x));
32574 }
32575 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32577 }
32578 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) ((wxEvtHandler *) x));
32580 }
32581 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32583 }
32584 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32586 }
32587 static void *_p_wxImageTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) ((wxImage *) x));
32589 }
32590 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32592 }
32593 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) ((wxSystemOptions *) x));
32595 }
32596 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32598 }
32599 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32601 }
32602 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32604 }
32605 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32607 }
32608 static void *_p_wxWindowTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32610 }
32611 static void *_p_wxMenuTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32613 }
32614 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32616 }
32617 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32619 }
32620 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) ((wxFileSystem *) x));
32622 }
32623 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32625 }
32626 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32628 }
32629 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32631 }
32632 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32634 }
32635 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32637 }
32638 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32640 }
32641 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) ((wxBusyInfo *) x));
32643 }
32644 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32646 }
32647 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32649 }
32650 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32652 }
32653 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32655 }
32656 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32658 }
32659 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32661 }
32662 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32664 }
32665 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32667 }
32668 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32670 }
32671 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32673 }
32674 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32675 return (void *)((wxLog *) ((wxLogStderr *) x));
32676 }
32677 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32678 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32679 }
32680 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32681 return (void *)((wxLog *) ((wxLogWindow *) x));
32682 }
32683 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32684 return (void *)((wxLog *) ((wxLogChain *) x));
32685 }
32686 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32687 return (void *)((wxLog *) ((wxLogGui *) x));
32688 }
32689 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32690 return (void *)((wxLog *) ((wxPyLog *) x));
32691 }
32692 static void *_p_wxControlTo_p_wxWindow(void *x) {
32693 return (void *)((wxWindow *) ((wxControl *) x));
32694 }
32695 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32696 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32697 }
32698 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32699 return (void *)((wxWindow *) ((wxMenuBar *) x));
32700 }
32701 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32702 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32703 }
32704 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32705 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32706 }
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747 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}};
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767 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}};
32768 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}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803
32804 static swig_type_info *swig_types_initial[] = {
32805 _swigt__p_wxLogChain,
32806 _swigt__p_wxMutexGuiLocker,
32807 _swigt__p_wxFileHistory,
32808 _swigt__p_wxLog,
32809 _swigt__p_wxMenu,
32810 _swigt__p_wxEvent,
32811 _swigt__p_wxDateTime__TimeZone,
32812 _swigt__p_wxConfigBase,
32813 _swigt__p_wxDisplay,
32814 _swigt__p_wxFileType,
32815 _swigt__p_wxLogGui,
32816 _swigt__p_wxFont,
32817 _swigt__p_wxDataFormat,
32818 _swigt__p_wxTimerEvent,
32819 _swigt__p_wxCaret,
32820 _swigt__ptrdiff_t,
32821 _swigt__std__ptrdiff_t,
32822 _swigt__p_int,
32823 _swigt__p_wxSize,
32824 _swigt__p_wxClipboard,
32825 _swigt__p_wxStopWatch,
32826 _swigt__p_wxDC,
32827 _swigt__p_wxClipboardLocker,
32828 _swigt__p_wxIcon,
32829 _swigt__p_wxLogStderr,
32830 _swigt__p_wxLogTextCtrl,
32831 _swigt__p_wxTextCtrl,
32832 _swigt__p_wxBusyCursor,
32833 _swigt__p_wxBitmapDataObject,
32834 _swigt__p_wxTextDataObject,
32835 _swigt__p_wxDataObject,
32836 _swigt__p_wxPyTextDataObject,
32837 _swigt__p_wxPyBitmapDataObject,
32838 _swigt__p_wxFileDataObject,
32839 _swigt__p_wxCustomDataObject,
32840 _swigt__p_wxURLDataObject,
32841 _swigt__p_wxMetafileDataObject,
32842 _swigt__p_wxSound,
32843 _swigt__p_wxTimerRunner,
32844 _swigt__p_wxLogWindow,
32845 _swigt__p_wxTimeSpan,
32846 _swigt__p_wxArrayString,
32847 _swigt__p_wxWindowDisabler,
32848 _swigt__p_form_ops_t,
32849 _swigt__p_wxToolTip,
32850 _swigt__p_wxDataObjectComposite,
32851 _swigt__p_wxSystemSettings,
32852 _swigt__p_wxFileConfig,
32853 _swigt__p_wxVideoMode,
32854 _swigt__p_wxDataObjectSimple,
32855 _swigt__p_wxPyDataObjectSimple,
32856 _swigt__p_wxDuplexMode,
32857 _swigt__p_wxEvtHandler,
32858 _swigt__p_wxRect,
32859 _swigt__p_char,
32860 _swigt__p_wxSingleInstanceChecker,
32861 _swigt__p_wxStandardPaths,
32862 _swigt__p_wxFileTypeInfo,
32863 _swigt__p_wxFrame,
32864 _swigt__p_wxTimer,
32865 _swigt__p_wxPaperSize,
32866 _swigt__p_wxMimeTypesManager,
32867 _swigt__p_wxPyArtProvider,
32868 _swigt__p_wxPyTipProvider,
32869 _swigt__p_wxTipProvider,
32870 _swigt__p_wxJoystick,
32871 _swigt__p_wxSystemOptions,
32872 _swigt__p_wxPoint,
32873 _swigt__p_wxJoystickEvent,
32874 _swigt__p_wxCursor,
32875 _swigt__p_wxObject,
32876 _swigt__p_wxOutputStream,
32877 _swigt__p_wxDateTime,
32878 _swigt__p_wxPyDropSource,
32879 _swigt__p_unsigned_long,
32880 _swigt__p_wxKillError,
32881 _swigt__p_wxWindow,
32882 _swigt__p_wxString,
32883 _swigt__p_wxPyProcess,
32884 _swigt__p_wxBitmap,
32885 _swigt__p_wxConfig,
32886 _swigt__unsigned_int,
32887 _swigt__p_unsigned_int,
32888 _swigt__p_unsigned_char,
32889 _swigt__p_wxChar,
32890 _swigt__p_wxBusyInfo,
32891 _swigt__p_wxPyDropTarget,
32892 _swigt__p_wxPyTextDropTarget,
32893 _swigt__p_wxPyFileDropTarget,
32894 _swigt__p_wxProcessEvent,
32895 _swigt__p_wxPyLog,
32896 _swigt__p_wxLogNull,
32897 _swigt__p_wxColour,
32898 _swigt__p_wxPyTimer,
32899 _swigt__p_wxConfigPathChanger,
32900 _swigt__p_wxDateSpan,
32901 0
32902 };
32903
32904
32905 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32906
32907 static swig_const_info swig_const_table[] = {
32908 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32909 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32910 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32911 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32912 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32913 {0, 0, 0, 0.0, 0, 0}};
32914
32915 #ifdef __cplusplus
32916 }
32917 #endif
32918
32919
32920 #ifdef __cplusplus
32921 extern "C" {
32922 #endif
32923
32924 /* Python-specific SWIG API */
32925 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32926 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32927 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32928
32929 /* -----------------------------------------------------------------------------
32930 * global variable support code.
32931 * ----------------------------------------------------------------------------- */
32932
32933 typedef struct swig_globalvar {
32934 char *name; /* Name of global variable */
32935 PyObject *(*get_attr)(); /* Return the current value */
32936 int (*set_attr)(PyObject *); /* Set the value */
32937 struct swig_globalvar *next;
32938 } swig_globalvar;
32939
32940 typedef struct swig_varlinkobject {
32941 PyObject_HEAD
32942 swig_globalvar *vars;
32943 } swig_varlinkobject;
32944
32945 static PyObject *
32946 swig_varlink_repr(swig_varlinkobject *v) {
32947 v = v;
32948 return PyString_FromString("<Swig global variables>");
32949 }
32950
32951 static int
32952 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32953 swig_globalvar *var;
32954 flags = flags;
32955 fprintf(fp,"Swig global variables { ");
32956 for (var = v->vars; var; var=var->next) {
32957 fprintf(fp,"%s", var->name);
32958 if (var->next) fprintf(fp,", ");
32959 }
32960 fprintf(fp," }\n");
32961 return 0;
32962 }
32963
32964 static PyObject *
32965 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32966 swig_globalvar *var = v->vars;
32967 while (var) {
32968 if (strcmp(var->name,n) == 0) {
32969 return (*var->get_attr)();
32970 }
32971 var = var->next;
32972 }
32973 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32974 return NULL;
32975 }
32976
32977 static int
32978 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32979 swig_globalvar *var = v->vars;
32980 while (var) {
32981 if (strcmp(var->name,n) == 0) {
32982 return (*var->set_attr)(p);
32983 }
32984 var = var->next;
32985 }
32986 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32987 return 1;
32988 }
32989
32990 static PyTypeObject varlinktype = {
32991 PyObject_HEAD_INIT(0)
32992 0, /* Number of items in variable part (ob_size) */
32993 (char *)"swigvarlink", /* Type name (tp_name) */
32994 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32995 0, /* Itemsize (tp_itemsize) */
32996 0, /* Deallocator (tp_dealloc) */
32997 (printfunc) swig_varlink_print, /* Print (tp_print) */
32998 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32999 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33000 0, /* tp_compare */
33001 (reprfunc) swig_varlink_repr, /* tp_repr */
33002 0, /* tp_as_number */
33003 0, /* tp_as_sequence */
33004 0, /* tp_as_mapping */
33005 0, /* tp_hash */
33006 0, /* tp_call */
33007 0, /* tp_str */
33008 0, /* tp_getattro */
33009 0, /* tp_setattro */
33010 0, /* tp_as_buffer */
33011 0, /* tp_flags */
33012 0, /* tp_doc */
33013 #if PY_VERSION_HEX >= 0x02000000
33014 0, /* tp_traverse */
33015 0, /* tp_clear */
33016 #endif
33017 #if PY_VERSION_HEX >= 0x02010000
33018 0, /* tp_richcompare */
33019 0, /* tp_weaklistoffset */
33020 #endif
33021 #if PY_VERSION_HEX >= 0x02020000
33022 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33023 #endif
33024 #if PY_VERSION_HEX >= 0x02030000
33025 0, /* tp_del */
33026 #endif
33027 #ifdef COUNT_ALLOCS
33028 0,0,0,0 /* tp_alloc -> tp_next */
33029 #endif
33030 };
33031
33032 /* Create a variable linking object for use later */
33033 static PyObject *
33034 SWIG_Python_newvarlink(void) {
33035 swig_varlinkobject *result = 0;
33036 result = PyMem_NEW(swig_varlinkobject,1);
33037 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33038 result->ob_type = &varlinktype;
33039 result->vars = 0;
33040 result->ob_refcnt = 0;
33041 Py_XINCREF((PyObject *) result);
33042 return ((PyObject*) result);
33043 }
33044
33045 static void
33046 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33047 swig_varlinkobject *v;
33048 swig_globalvar *gv;
33049 v= (swig_varlinkobject *) p;
33050 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33051 gv->name = (char *) malloc(strlen(name)+1);
33052 strcpy(gv->name,name);
33053 gv->get_attr = get_attr;
33054 gv->set_attr = set_attr;
33055 gv->next = v->vars;
33056 v->vars = gv;
33057 }
33058
33059 /* -----------------------------------------------------------------------------
33060 * constants/methods manipulation
33061 * ----------------------------------------------------------------------------- */
33062
33063 /* Install Constants */
33064 static void
33065 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33066 PyObject *obj = 0;
33067 size_t i;
33068 for (i = 0; constants[i].type; i++) {
33069 switch(constants[i].type) {
33070 case SWIG_PY_INT:
33071 obj = PyInt_FromLong(constants[i].lvalue);
33072 break;
33073 case SWIG_PY_FLOAT:
33074 obj = PyFloat_FromDouble(constants[i].dvalue);
33075 break;
33076 case SWIG_PY_STRING:
33077 if (constants[i].pvalue) {
33078 obj = PyString_FromString((char *) constants[i].pvalue);
33079 } else {
33080 Py_INCREF(Py_None);
33081 obj = Py_None;
33082 }
33083 break;
33084 case SWIG_PY_POINTER:
33085 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33086 break;
33087 case SWIG_PY_BINARY:
33088 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33089 break;
33090 default:
33091 obj = 0;
33092 break;
33093 }
33094 if (obj) {
33095 PyDict_SetItemString(d,constants[i].name,obj);
33096 Py_DECREF(obj);
33097 }
33098 }
33099 }
33100
33101 /* -----------------------------------------------------------------------------*/
33102 /* Fix SwigMethods to carry the callback ptrs when needed */
33103 /* -----------------------------------------------------------------------------*/
33104
33105 static void
33106 SWIG_Python_FixMethods(PyMethodDef *methods,
33107 swig_const_info *const_table,
33108 swig_type_info **types,
33109 swig_type_info **types_initial) {
33110 size_t i;
33111 for (i = 0; methods[i].ml_name; ++i) {
33112 char *c = methods[i].ml_doc;
33113 if (c && (c = strstr(c, "swig_ptr: "))) {
33114 int j;
33115 swig_const_info *ci = 0;
33116 char *name = c + 10;
33117 for (j = 0; const_table[j].type; j++) {
33118 if (strncmp(const_table[j].name, name,
33119 strlen(const_table[j].name)) == 0) {
33120 ci = &(const_table[j]);
33121 break;
33122 }
33123 }
33124 if (ci) {
33125 size_t shift = (ci->ptype) - types;
33126 swig_type_info *ty = types_initial[shift];
33127 size_t ldoc = (c - methods[i].ml_doc);
33128 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33129 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33130 char *buff = ndoc;
33131 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33132 strncpy(buff, methods[i].ml_doc, ldoc);
33133 buff += ldoc;
33134 strncpy(buff, "swig_ptr: ", 10);
33135 buff += 10;
33136 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33137 methods[i].ml_doc = ndoc;
33138 }
33139 }
33140 }
33141 }
33142
33143 /* -----------------------------------------------------------------------------*
33144 * Initialize type list
33145 * -----------------------------------------------------------------------------*/
33146
33147 #if PY_MAJOR_VERSION < 2
33148 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33149 is copied out of Python/modsupport.c in python version 2.3.4 */
33150 static int
33151 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33152 {
33153 PyObject *dict;
33154 if (!PyModule_Check(m)) {
33155 PyErr_SetString(PyExc_TypeError,
33156 "PyModule_AddObject() needs module as first arg");
33157 return -1;
33158 }
33159 if (!o) {
33160 PyErr_SetString(PyExc_TypeError,
33161 "PyModule_AddObject() needs non-NULL value");
33162 return -1;
33163 }
33164
33165 dict = PyModule_GetDict(m);
33166 if (dict == NULL) {
33167 /* Internal error -- modules must have a dict! */
33168 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33169 PyModule_GetName(m));
33170 return -1;
33171 }
33172 if (PyDict_SetItemString(dict, name, o))
33173 return -1;
33174 Py_DECREF(o);
33175 return 0;
33176 }
33177 #endif
33178
33179 static swig_type_info **
33180 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33181 static PyMethodDef swig_empty_runtime_method_table[] = {
33182 {
33183 NULL, NULL, 0, NULL
33184 }
33185 };/* Sentinel */
33186
33187 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33188 swig_empty_runtime_method_table);
33189 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33190 if (pointer && module) {
33191 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33192 }
33193 return type_list_handle;
33194 }
33195
33196 static swig_type_info **
33197 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33198 swig_type_info **type_pointer;
33199
33200 /* first check if module already created */
33201 type_pointer = SWIG_Python_GetTypeListHandle();
33202 if (type_pointer) {
33203 return type_pointer;
33204 } else {
33205 /* create a new module and variable */
33206 return SWIG_Python_SetTypeListHandle(type_list_handle);
33207 }
33208 }
33209
33210 #ifdef __cplusplus
33211 }
33212 #endif
33213
33214 /* -----------------------------------------------------------------------------*
33215 * Partial Init method
33216 * -----------------------------------------------------------------------------*/
33217
33218 #ifdef SWIG_LINK_RUNTIME
33219 #ifdef __cplusplus
33220 extern "C"
33221 #endif
33222 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33223 #endif
33224
33225 #ifdef __cplusplus
33226 extern "C"
33227 #endif
33228 SWIGEXPORT(void) SWIG_init(void) {
33229 static PyObject *SWIG_globals = 0;
33230 static int typeinit = 0;
33231 PyObject *m, *d;
33232 int i;
33233 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33234
33235 /* Fix SwigMethods to carry the callback ptrs when needed */
33236 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33237
33238 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33239 d = PyModule_GetDict(m);
33240
33241 if (!typeinit) {
33242 #ifdef SWIG_LINK_RUNTIME
33243 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33244 #else
33245 # ifndef SWIG_STATIC_RUNTIME
33246 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33247 # endif
33248 #endif
33249 for (i = 0; swig_types_initial[i]; i++) {
33250 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33251 }
33252 typeinit = 1;
33253 }
33254 SWIG_InstallConstants(d,swig_const_table);
33255
33256 {
33257 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33270 }
33271 {
33272 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33276 }
33277 {
33278 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33279 }
33280 {
33281 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33282 }
33283 {
33284 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33285 }
33286 {
33287 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33288 }
33289 {
33290 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33291 }
33292 {
33293 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33294 }
33295 {
33296 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33297 }
33298 {
33299 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33345 }
33346 {
33347 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33348 }
33349 {
33350 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33351 }
33352 {
33353 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33354 }
33355 {
33356 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33528 }
33529 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33530 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33531 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33532 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33533 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33534 {
33535 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33545 }
33546 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33547
33548 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33549
33550 {
33551 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33582 }
33583 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33584 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33585 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33586 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33587 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33588 {
33589 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33680 }
33681 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33682 {
33683 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33696 }
33697
33698 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33699
33700 {
33701 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33720 }
33721 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33722 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33723 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33724 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33725 {
33726 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33748 }
33749 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33750 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33751 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33752 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33753 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33754 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33755 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33756 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33757 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33758 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33759 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33760 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33761 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33762 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33763 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33764 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33765 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33766 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33769 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33770 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33771 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33772 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33773 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33774 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33775 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33776 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33777 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33778 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33779 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33780 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33781 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33782 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33783 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33784 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33785 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33786 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33787 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33788 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33789 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33790 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33791 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33792 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33793 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33794 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33795 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33796 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33797 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33798 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33799 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33800 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33801 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33802 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33803 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33804 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33805
33806 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33807
33808 {
33809 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33834 }
33835 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33837 {
33838 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34301 }
34302 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34303 {
34304 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34362 }
34363 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34364 {
34365 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34399 }
34400
34401 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34402 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34403 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34404 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34405
34406 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34407 }
34408
wxWidgets (Impactor)