]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wx.Rect.Inflate/Defalte docs
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_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_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings 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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711
1712 int wxCaret_GetBlinkTime() {
1713 return wxCaret::GetBlinkTime();
1714 }
1715
1716 void wxCaret_SetBlinkTime(int milliseconds) {
1717 wxCaret::SetBlinkTime(milliseconds);
1718 }
1719
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133
2134 #include <wx/mimetype.h>
2135
2136 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2137 wxString str;
2138 if (self->GetMimeType(&str))
2139 return wx2PyString(str);
2140 else
2141 RETURN_NONE();
2142 }
2143 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2144 wxArrayString arr;
2145 if (self->GetMimeTypes(arr))
2146 return wxArrayString2PyList_helper(arr);
2147 else
2148 RETURN_NONE();
2149 }
2150 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2151 wxArrayString arr;
2152 if (self->GetExtensions(arr))
2153 return wxArrayString2PyList_helper(arr);
2154 else
2155 RETURN_NONE();
2156 }
2157 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2158 wxIconLocation loc;
2159 if (self->GetIcon(&loc))
2160 return new wxIcon(loc);
2161 else
2162 return NULL;
2163 }
2164 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2165 wxIconLocation loc;
2166 if (self->GetIcon(&loc)) {
2167 wxString iconFile = loc.GetFileName();
2168 int iconIndex = -1;
2169
2170 iconIndex = loc.GetIndex();
2171
2172 // Make a tuple and put the values in it
2173 bool blocked = wxPyBeginBlockThreads();
2174 PyObject* tuple = PyTuple_New(3);
2175 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2176 wxT("wxIcon"), true));
2177 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2178 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2179 wxPyEndBlockThreads(blocked);
2180 return tuple;
2181 }
2182 else
2183 RETURN_NONE();
2184 }
2185 static PyObject *wxFileType_GetDescription(wxFileType *self){
2186 wxString str;
2187 if (self->GetDescription(&str))
2188 return wx2PyString(str);
2189 else
2190 RETURN_NONE();
2191 }
2192 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2193 wxString str;
2194 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2195 return wx2PyString(str);
2196 else
2197 RETURN_NONE();
2198 }
2199 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2200 wxString str;
2201 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2202 return wx2PyString(str);
2203 else
2204 RETURN_NONE();
2205 }
2206 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2207 wxArrayString verbs;
2208 wxArrayString commands;
2209 if (self->GetAllCommands(&verbs, &commands,
2210 wxFileType::MessageParameters(filename, mimetype))) {
2211 bool blocked = wxPyBeginBlockThreads();
2212 PyObject* tuple = PyTuple_New(2);
2213 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2214 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2215 wxPyEndBlockThreads(blocked);
2216 return tuple;
2217 }
2218 else
2219 RETURN_NONE();
2220 }
2221 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2222 return wxFileType::ExpandCommand(command,
2223 wxFileType::MessageParameters(filename, mimetype));
2224 }
2225 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2226 wxArrayString arr;
2227 self->EnumAllFileTypes(arr);
2228 return wxArrayString2PyList_helper(arr);
2229 }
2230
2231 #include <wx/artprov.h>
2232
2233 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2234 static const wxString wxPyART_MENU(wxART_MENU);
2235 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2236 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2237 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2238 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2239 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2240 static const wxString wxPyART_OTHER(wxART_OTHER);
2241 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2242 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2243 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2244 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2245 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2246 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2247 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2248 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2249 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2250 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2251 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2252 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2253 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2254 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2255 static const wxString wxPyART_PRINT(wxART_PRINT);
2256 static const wxString wxPyART_HELP(wxART_HELP);
2257 static const wxString wxPyART_TIP(wxART_TIP);
2258 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2259 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2260 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2261 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2262 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2263 static const wxString wxPyART_CDROM(wxART_CDROM);
2264 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2265 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2266 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2267 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2268 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2269 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2270 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2271 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2272 static const wxString wxPyART_ERROR(wxART_ERROR);
2273 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2274 static const wxString wxPyART_WARNING(wxART_WARNING);
2275 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2276 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2277 // Python aware wxArtProvider
2278 class wxPyArtProvider : public wxArtProvider {
2279 public:
2280
2281 virtual wxBitmap CreateBitmap(const wxArtID& id,
2282 const wxArtClient& client,
2283 const wxSize& size) {
2284 wxBitmap rval = wxNullBitmap;
2285 bool blocked = wxPyBeginBlockThreads();
2286 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2287 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2288 PyObject* ro;
2289 wxBitmap* ptr;
2290 PyObject* s1, *s2;
2291 s1 = wx2PyString(id);
2292 s2 = wx2PyString(client);
2293 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2294 Py_DECREF(so);
2295 Py_DECREF(s1);
2296 Py_DECREF(s2);
2297 if (ro) {
2298 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2299 rval = *ptr;
2300 Py_DECREF(ro);
2301 }
2302 }
2303 wxPyEndBlockThreads(blocked);
2304 return rval;
2305 }
2306
2307 PYPRIVATE;
2308 };
2309
2310 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2311
2312
2313
2314 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2315 PyObject* ret = PyTuple_New(3);
2316 if (ret) {
2317 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2318 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2319 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2320 }
2321 return ret;
2322 }
2323
2324 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2325 bool cont;
2326 long index = 0;
2327 wxString value;
2328
2329 cont = self->GetFirstGroup(value, index);
2330 return __EnumerationHelper(cont, value, index);
2331 }
2332 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2333 bool cont;
2334 wxString value;
2335
2336 cont = self->GetNextGroup(value, index);
2337 return __EnumerationHelper(cont, value, index);
2338 }
2339 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2340 bool cont;
2341 long index = 0;
2342 wxString value;
2343
2344 cont = self->GetFirstEntry(value, index);
2345 return __EnumerationHelper(cont, value, index);
2346 }
2347 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2348 bool cont;
2349 wxString value;
2350
2351 cont = self->GetNextEntry(value, index);
2352 return __EnumerationHelper(cont, value, index);
2353 }
2354 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2355 long rv;
2356 self->Read(key, &rv, defaultVal);
2357 return rv;
2358 }
2359
2360 SWIGINTERN int
2361 SWIG_AsVal_double(PyObject *obj, double* val)
2362 {
2363 if (PyNumber_Check(obj)) {
2364 if (val) *val = PyFloat_AsDouble(obj);
2365 return 1;
2366 }
2367 else {
2368 SWIG_type_error("number", obj);
2369 }
2370 return 0;
2371 }
2372
2373
2374 SWIGINTERNSHORT double
2375 SWIG_As_double(PyObject* obj)
2376 {
2377 double v;
2378 if (!SWIG_AsVal_double(obj, &v)) {
2379 /*
2380 this is needed to make valgrind/purify happier.
2381 */
2382 memset((void*)&v, 0, sizeof(double));
2383 }
2384 return v;
2385 }
2386
2387
2388 SWIGINTERNSHORT int
2389 SWIG_Check_double(PyObject* obj)
2390 {
2391 return SWIG_AsVal_double(obj, (double*)0);
2392 }
2393
2394 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2395 double rv;
2396 self->Read(key, &rv, defaultVal);
2397 return rv;
2398 }
2399
2400 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2401 #define SWIG_From_double PyFloat_FromDouble
2402 /*@@*/
2403
2404 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2405 bool rv;
2406 self->Read(key, &rv, defaultVal);
2407 return rv;
2408 }
2409
2410 #include <wx/datetime.h>
2411
2412 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2413 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2414
2415 #define LOCAL_TZ wxDateTime::Local
2416
2417
2418 #if UINT_MAX < LONG_MAX
2419 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2420 #define SWIG_From_unsigned_SS_int SWIG_From_long
2421 /*@@*/
2422 #else
2423 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2424 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2425 /*@@*/
2426 #endif
2427
2428 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2429 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2430 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2431 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2432 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2433 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2434 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2435 return (*self < *other);
2436 }
2437 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2438 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2439 return (*self <= *other);
2440 }
2441 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2442 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2443 return (*self > *other);
2444 }
2445 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2446 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2447 return (*self >= *other);
2448 }
2449 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2450 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2451 return (*self == *other);
2452 }
2453 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2454 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2455 return (*self != *other);
2456 }
2457 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2458 const wxChar* rv;
2459 const wxChar* _date = date;
2460 rv = self->ParseRfc822Date(_date);
2461 if (rv == NULL) return -1;
2462 return rv - _date;
2463 }
2464 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2465 const wxChar* rv;
2466 const wxChar* _date = date;
2467 rv = self->ParseFormat(_date, format, dateDef);
2468 if (rv == NULL) return -1;
2469 return rv - _date;
2470 }
2471 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2472 const wxChar* rv;
2473 const wxChar* _datetime = datetime;
2474 rv = self->ParseDateTime(_datetime);
2475 if (rv == NULL) return -1;
2476 return rv - _datetime;
2477 }
2478 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2479 const wxChar* rv;
2480 const wxChar* _date = date;
2481 rv = self->ParseDate(_date);
2482 if (rv == NULL) return -1;
2483 return rv - _date;
2484 }
2485 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2486 const wxChar* rv;
2487 const wxChar* _time = time;
2488 rv = self->ParseTime(_time);
2489 if (rv == NULL) return -1;
2490 return rv - _time;
2491 }
2492 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2493 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2494 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2495 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2496 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2497 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2498 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2499 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2500 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2501 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2502 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2503 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2504 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2505 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2506 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2507 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2508
2509 #include <wx/dataobj.h>
2510
2511 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2512 size_t count = self->GetFormatCount(dir);
2513 wxDataFormat* formats = new wxDataFormat[count];
2514 self->GetAllFormats(formats, dir);
2515
2516 bool blocked = wxPyBeginBlockThreads();
2517 PyObject* list = PyList_New(count);
2518 for (size_t i=0; i<count; i++) {
2519 wxDataFormat* format = new wxDataFormat(formats[i]);
2520 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2521 PyList_Append(list, obj);
2522 Py_DECREF(obj);
2523 }
2524 wxPyEndBlockThreads(blocked);
2525 delete [] formats;
2526 return list;
2527 }
2528 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2529 PyObject* rval = NULL;
2530 size_t size = self->GetDataSize(format);
2531 bool blocked = wxPyBeginBlockThreads();
2532 if (size) {
2533 char* buf = new char[size];
2534 if (self->GetDataHere(format, buf))
2535 rval = PyString_FromStringAndSize(buf, size);
2536 delete [] buf;
2537 }
2538 if (! rval) {
2539 rval = Py_None;
2540 Py_INCREF(rval);
2541 }
2542 wxPyEndBlockThreads(blocked);
2543 return rval;
2544 }
2545 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2546 bool rval;
2547 bool blocked = wxPyBeginBlockThreads();
2548 if (PyString_Check(data)) {
2549 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2550 }
2551 else {
2552 // raise a TypeError if not a string
2553 PyErr_SetString(PyExc_TypeError, "String expected.");
2554 rval = false;
2555 }
2556 wxPyEndBlockThreads(blocked);
2557 return rval;
2558 }
2559 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2560 PyObject* rval = NULL;
2561 size_t size = self->GetDataSize();
2562 bool blocked = wxPyBeginBlockThreads();
2563 if (size) {
2564 char* buf = new char[size];
2565 if (self->GetDataHere(buf))
2566 rval = PyString_FromStringAndSize(buf, size);
2567 delete [] buf;
2568 }
2569 if (! rval) {
2570 rval = Py_None;
2571 Py_INCREF(rval);
2572 }
2573 wxPyEndBlockThreads(blocked);
2574 return rval;
2575 }
2576 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2577 bool rval;
2578 bool blocked = wxPyBeginBlockThreads();
2579 if (PyString_Check(data)) {
2580 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2581 }
2582 else {
2583 // raise a TypeError if not a string
2584 PyErr_SetString(PyExc_TypeError, "String expected.");
2585 rval = false;
2586 }
2587 wxPyEndBlockThreads(blocked);
2588 return rval;
2589 }
2590 // Create a new class for wxPython to use
2591 class wxPyDataObjectSimple : public wxDataObjectSimple {
2592 public:
2593 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2594 : wxDataObjectSimple(format) {}
2595
2596 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2597 bool GetDataHere(void *buf) const;
2598 bool SetData(size_t len, const void *buf) const;
2599 PYPRIVATE;
2600 };
2601
2602 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2603
2604 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2605 // We need to get the data for this object and write it to buf. I think
2606 // the best way to do this for wxPython is to have the Python method
2607 // return either a string or None and then act appropriately with the
2608 // C++ version.
2609
2610 bool rval = false;
2611 bool blocked = wxPyBeginBlockThreads();
2612 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2613 PyObject* ro;
2614 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2615 if (ro) {
2616 rval = (ro != Py_None && PyString_Check(ro));
2617 if (rval)
2618 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2619 Py_DECREF(ro);
2620 }
2621 }
2622 wxPyEndBlockThreads(blocked);
2623 return rval;
2624 }
2625
2626 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2627 // For this one we simply need to make a string from buf and len
2628 // and send it to the Python method.
2629 bool rval = false;
2630 bool blocked = wxPyBeginBlockThreads();
2631 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2632 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2633 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2634 Py_DECREF(data);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 return rval;
2638 }
2639
2640 // Create a new class for wxPython to use
2641 class wxPyTextDataObject : public wxTextDataObject {
2642 public:
2643 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2644 : wxTextDataObject(text) {}
2645
2646 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2647 DEC_PYCALLBACK_STRING__const(GetText);
2648 DEC_PYCALLBACK__STRING(SetText);
2649 PYPRIVATE;
2650 };
2651
2652 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2653 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2654 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2655
2656
2657 // Create a new class for wxPython to use
2658 class wxPyBitmapDataObject : public wxBitmapDataObject {
2659 public:
2660 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2661 : wxBitmapDataObject(bitmap) {}
2662
2663 wxBitmap GetBitmap() const;
2664 void SetBitmap(const wxBitmap& bitmap);
2665 PYPRIVATE;
2666 };
2667
2668 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2669 wxBitmap* rval = &wxNullBitmap;
2670 bool blocked = wxPyBeginBlockThreads();
2671 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2672 PyObject* ro;
2673 wxBitmap* ptr;
2674 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2675 if (ro) {
2676 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2677 rval = ptr;
2678 Py_DECREF(ro);
2679 }
2680 }
2681 wxPyEndBlockThreads(blocked);
2682 return *rval;
2683 }
2684
2685 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2686 bool blocked = wxPyBeginBlockThreads();
2687 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2688 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2689 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2690 Py_DECREF(bo);
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 }
2694
2695 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2696 return new wxCustomDataObject(wxDataFormat(formatName));
2697 }
2698 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2699 bool rval;
2700 bool blocked = wxPyBeginBlockThreads();
2701 if (PyString_Check(data)) {
2702 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2703 }
2704 else {
2705 // raise a TypeError if not a string
2706 PyErr_SetString(PyExc_TypeError, "String expected.");
2707 rval = false;
2708 }
2709 wxPyEndBlockThreads(blocked);
2710 return rval;
2711 }
2712 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2713 PyObject* obj;
2714 bool blocked = wxPyBeginBlockThreads();
2715 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2716 wxPyEndBlockThreads(blocked);
2717 return obj;
2718 }
2719
2720 #include <wx/metafile.h>
2721
2722
2723 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2724
2725
2726 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2727 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2728 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2729 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2730 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2731
2732
2733 class wxPyTextDropTarget : public wxTextDropTarget {
2734 public:
2735 wxPyTextDropTarget() {}
2736
2737 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2738
2739 DEC_PYCALLBACK__(OnLeave);
2740 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2741 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2742 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2743 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2744
2745 PYPRIVATE;
2746 };
2747
2748 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2749 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2750 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2751 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2752 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2753 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2754
2755
2756
2757 class wxPyFileDropTarget : public wxFileDropTarget {
2758 public:
2759 wxPyFileDropTarget() {}
2760
2761 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2762
2763 DEC_PYCALLBACK__(OnLeave);
2764 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2765 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2766 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2767 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2768
2769 PYPRIVATE;
2770 };
2771
2772 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2773 const wxArrayString& filenames) {
2774 bool rval = false;
2775 bool blocked = wxPyBeginBlockThreads();
2776 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2777 PyObject* list = wxArrayString2PyList_helper(filenames);
2778 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2779 Py_DECREF(list);
2780 }
2781 wxPyEndBlockThreads(blocked);
2782 return rval;
2783 }
2784
2785
2786
2787 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2788 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2789 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2790 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2791 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2792
2793
2794
2795
2796 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2797
2798 #include <wx/display.h>
2799
2800 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2801 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2802
2803 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2804 #if !wxUSE_DISPLAY
2805 #include <wx/dynarray.h>
2806 #include <wx/vidmode.h>
2807
2808 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2809 #include "wx/arrimpl.cpp"
2810 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2811 const wxVideoMode wxDefaultVideoMode;
2812
2813 class wxDisplay
2814 {
2815 public:
2816 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2817 ~wxDisplay() {}
2818
2819 static size_t GetCount()
2820 { wxPyRaiseNotImplemented(); return 0; }
2821
2822 static int GetFromPoint(const wxPoint& pt)
2823 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2824 static int GetFromWindow(wxWindow *window)
2825 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2826
2827 virtual bool IsOk() const { return false; }
2828 virtual wxRect GetGeometry() const { wxRect r; return r; }
2829 virtual wxString GetName() const { return wxEmptyString; }
2830 bool IsPrimary() const { return false; }
2831
2832 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2833 { wxArrayVideoModes a; return a; }
2834
2835 virtual wxVideoMode GetCurrentMode() const
2836 { return wxDefaultVideoMode; }
2837
2838 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2839 { return false; }
2840
2841 void ResetMode() {}
2842 };
2843 #endif
2844
2845 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2846 PyObject* pyList = NULL;
2847 wxArrayVideoModes arr = self->GetModes(mode);
2848 bool blocked = wxPyBeginBlockThreads();
2849 pyList = PyList_New(0);
2850 for (int i=0; i < arr.GetCount(); i++) {
2851 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2852 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2853 PyList_Append(pyList, pyObj);
2854 Py_DECREF(pyObj);
2855 }
2856 wxPyEndBlockThreads(blocked);
2857 return pyList;
2858 }
2859
2860 #include <wx/stdpaths.h>
2861
2862 static wxStandardPaths *StandardPaths_Get(){
2863 return (wxStandardPaths*) &wxStandardPaths::Get();
2864 }
2865 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2866 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2867 #ifdef __cplusplus
2868 extern "C" {
2869 #endif
2870 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2871 PyObject *resultobj;
2872 wxSystemColour arg1 ;
2873 wxColour result;
2874 PyObject * obj0 = 0 ;
2875 char *kwnames[] = {
2876 (char *) "index", NULL
2877 };
2878
2879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2880 {
2881 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2882 if (SWIG_arg_fail(1)) SWIG_fail;
2883 }
2884 {
2885 if (!wxPyCheckForApp()) SWIG_fail;
2886 PyThreadState* __tstate = wxPyBeginAllowThreads();
2887 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2888
2889 wxPyEndAllowThreads(__tstate);
2890 if (PyErr_Occurred()) SWIG_fail;
2891 }
2892 {
2893 wxColour * resultptr;
2894 resultptr = new wxColour((wxColour &)(result));
2895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2896 }
2897 return resultobj;
2898 fail:
2899 return NULL;
2900 }
2901
2902
2903 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2904 PyObject *resultobj;
2905 wxSystemFont arg1 ;
2906 wxFont result;
2907 PyObject * obj0 = 0 ;
2908 char *kwnames[] = {
2909 (char *) "index", NULL
2910 };
2911
2912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2913 {
2914 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2915 if (SWIG_arg_fail(1)) SWIG_fail;
2916 }
2917 {
2918 if (!wxPyCheckForApp()) SWIG_fail;
2919 PyThreadState* __tstate = wxPyBeginAllowThreads();
2920 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2921
2922 wxPyEndAllowThreads(__tstate);
2923 if (PyErr_Occurred()) SWIG_fail;
2924 }
2925 {
2926 wxFont * resultptr;
2927 resultptr = new wxFont((wxFont &)(result));
2928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2929 }
2930 return resultobj;
2931 fail:
2932 return NULL;
2933 }
2934
2935
2936 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2937 PyObject *resultobj;
2938 wxSystemMetric arg1 ;
2939 int result;
2940 PyObject * obj0 = 0 ;
2941 char *kwnames[] = {
2942 (char *) "index", NULL
2943 };
2944
2945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2946 {
2947 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2948 if (SWIG_arg_fail(1)) SWIG_fail;
2949 }
2950 {
2951 if (!wxPyCheckForApp()) SWIG_fail;
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = SWIG_From_int((int)(result));
2960 }
2961 return resultobj;
2962 fail:
2963 return NULL;
2964 }
2965
2966
2967 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2968 PyObject *resultobj;
2969 wxSystemFeature arg1 ;
2970 bool result;
2971 PyObject * obj0 = 0 ;
2972 char *kwnames[] = {
2973 (char *) "index", NULL
2974 };
2975
2976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2977 {
2978 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2979 if (SWIG_arg_fail(1)) SWIG_fail;
2980 }
2981 {
2982 if (!wxPyCheckForApp()) SWIG_fail;
2983 PyThreadState* __tstate = wxPyBeginAllowThreads();
2984 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2985
2986 wxPyEndAllowThreads(__tstate);
2987 if (PyErr_Occurred()) SWIG_fail;
2988 }
2989 {
2990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2991 }
2992 return resultobj;
2993 fail:
2994 return NULL;
2995 }
2996
2997
2998 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
2999 PyObject *resultobj;
3000 wxSystemScreenType result;
3001 char *kwnames[] = {
3002 NULL
3003 };
3004
3005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3006 {
3007 if (!wxPyCheckForApp()) SWIG_fail;
3008 PyThreadState* __tstate = wxPyBeginAllowThreads();
3009 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3010
3011 wxPyEndAllowThreads(__tstate);
3012 if (PyErr_Occurred()) SWIG_fail;
3013 }
3014 resultobj = SWIG_From_int((result));
3015 return resultobj;
3016 fail:
3017 return NULL;
3018 }
3019
3020
3021 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3022 PyObject *resultobj;
3023 wxSystemScreenType arg1 ;
3024 PyObject * obj0 = 0 ;
3025 char *kwnames[] = {
3026 (char *) "screen", NULL
3027 };
3028
3029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3030 {
3031 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3032 if (SWIG_arg_fail(1)) SWIG_fail;
3033 }
3034 {
3035 if (!wxPyCheckForApp()) SWIG_fail;
3036 PyThreadState* __tstate = wxPyBeginAllowThreads();
3037 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3038
3039 wxPyEndAllowThreads(__tstate);
3040 if (PyErr_Occurred()) SWIG_fail;
3041 }
3042 Py_INCREF(Py_None); resultobj = Py_None;
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3050 PyObject *obj;
3051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3052 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3053 Py_INCREF(obj);
3054 return Py_BuildValue((char *)"");
3055 }
3056 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3057 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3058 return 1;
3059 }
3060
3061
3062 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3063 PyObject *pyobj;
3064
3065 {
3066 #if wxUSE_UNICODE
3067 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3068 #else
3069 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3070 #endif
3071 }
3072 return pyobj;
3073 }
3074
3075
3076 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3077 PyObject *resultobj;
3078 wxSystemOptions *result;
3079 char *kwnames[] = {
3080 NULL
3081 };
3082
3083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3084 {
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (wxSystemOptions *)new wxSystemOptions();
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3099 PyObject *resultobj;
3100 wxString *arg1 = 0 ;
3101 wxString *arg2 = 0 ;
3102 bool temp1 = false ;
3103 bool temp2 = false ;
3104 PyObject * obj0 = 0 ;
3105 PyObject * obj1 = 0 ;
3106 char *kwnames[] = {
3107 (char *) "name",(char *) "value", NULL
3108 };
3109
3110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3111 {
3112 arg1 = wxString_in_helper(obj0);
3113 if (arg1 == NULL) SWIG_fail;
3114 temp1 = true;
3115 }
3116 {
3117 arg2 = wxString_in_helper(obj1);
3118 if (arg2 == NULL) SWIG_fail;
3119 temp2 = true;
3120 }
3121 {
3122 PyThreadState* __tstate = wxPyBeginAllowThreads();
3123 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3124
3125 wxPyEndAllowThreads(__tstate);
3126 if (PyErr_Occurred()) SWIG_fail;
3127 }
3128 Py_INCREF(Py_None); resultobj = Py_None;
3129 {
3130 if (temp1)
3131 delete arg1;
3132 }
3133 {
3134 if (temp2)
3135 delete arg2;
3136 }
3137 return resultobj;
3138 fail:
3139 {
3140 if (temp1)
3141 delete arg1;
3142 }
3143 {
3144 if (temp2)
3145 delete arg2;
3146 }
3147 return NULL;
3148 }
3149
3150
3151 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3152 PyObject *resultobj;
3153 wxString *arg1 = 0 ;
3154 int arg2 ;
3155 bool temp1 = false ;
3156 PyObject * obj0 = 0 ;
3157 PyObject * obj1 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "name",(char *) "value", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3163 {
3164 arg1 = wxString_in_helper(obj0);
3165 if (arg1 == NULL) SWIG_fail;
3166 temp1 = true;
3167 }
3168 {
3169 arg2 = (int)(SWIG_As_int(obj1));
3170 if (SWIG_arg_fail(2)) SWIG_fail;
3171 }
3172 {
3173 PyThreadState* __tstate = wxPyBeginAllowThreads();
3174 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3175
3176 wxPyEndAllowThreads(__tstate);
3177 if (PyErr_Occurred()) SWIG_fail;
3178 }
3179 Py_INCREF(Py_None); resultobj = Py_None;
3180 {
3181 if (temp1)
3182 delete arg1;
3183 }
3184 return resultobj;
3185 fail:
3186 {
3187 if (temp1)
3188 delete arg1;
3189 }
3190 return NULL;
3191 }
3192
3193
3194 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3195 PyObject *resultobj;
3196 wxString *arg1 = 0 ;
3197 wxString result;
3198 bool temp1 = false ;
3199 PyObject * obj0 = 0 ;
3200 char *kwnames[] = {
3201 (char *) "name", NULL
3202 };
3203
3204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3205 {
3206 arg1 = wxString_in_helper(obj0);
3207 if (arg1 == NULL) SWIG_fail;
3208 temp1 = true;
3209 }
3210 {
3211 PyThreadState* __tstate = wxPyBeginAllowThreads();
3212 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3213
3214 wxPyEndAllowThreads(__tstate);
3215 if (PyErr_Occurred()) SWIG_fail;
3216 }
3217 {
3218 #if wxUSE_UNICODE
3219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3220 #else
3221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3222 #endif
3223 }
3224 {
3225 if (temp1)
3226 delete arg1;
3227 }
3228 return resultobj;
3229 fail:
3230 {
3231 if (temp1)
3232 delete arg1;
3233 }
3234 return NULL;
3235 }
3236
3237
3238 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxString *arg1 = 0 ;
3241 int result;
3242 bool temp1 = false ;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "name", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3249 {
3250 arg1 = wxString_in_helper(obj0);
3251 if (arg1 == NULL) SWIG_fail;
3252 temp1 = true;
3253 }
3254 {
3255 PyThreadState* __tstate = wxPyBeginAllowThreads();
3256 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3257
3258 wxPyEndAllowThreads(__tstate);
3259 if (PyErr_Occurred()) SWIG_fail;
3260 }
3261 {
3262 resultobj = SWIG_From_int((int)(result));
3263 }
3264 {
3265 if (temp1)
3266 delete arg1;
3267 }
3268 return resultobj;
3269 fail:
3270 {
3271 if (temp1)
3272 delete arg1;
3273 }
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxString *arg1 = 0 ;
3281 bool result;
3282 bool temp1 = false ;
3283 PyObject * obj0 = 0 ;
3284 char *kwnames[] = {
3285 (char *) "name", NULL
3286 };
3287
3288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3289 {
3290 arg1 = wxString_in_helper(obj0);
3291 if (arg1 == NULL) SWIG_fail;
3292 temp1 = true;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 {
3302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3303 }
3304 {
3305 if (temp1)
3306 delete arg1;
3307 }
3308 return resultobj;
3309 fail:
3310 {
3311 if (temp1)
3312 delete arg1;
3313 }
3314 return NULL;
3315 }
3316
3317
3318 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3319 PyObject *obj;
3320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3321 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3322 Py_INCREF(obj);
3323 return Py_BuildValue((char *)"");
3324 }
3325 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3326 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3327 return 1;
3328 }
3329
3330
3331 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3332 PyObject *pyobj;
3333
3334 {
3335 #if wxUSE_UNICODE
3336 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3337 #else
3338 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3339 #endif
3340 }
3341 return pyobj;
3342 }
3343
3344
3345 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3346 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3347 return 1;
3348 }
3349
3350
3351 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3352 PyObject *pyobj;
3353
3354 {
3355 #if wxUSE_UNICODE
3356 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3357 #else
3358 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3359 #endif
3360 }
3361 return pyobj;
3362 }
3363
3364
3365 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3366 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3367 return 1;
3368 }
3369
3370
3371 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3372 PyObject *pyobj;
3373
3374 {
3375 #if wxUSE_UNICODE
3376 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3377 #else
3378 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3379 #endif
3380 }
3381 return pyobj;
3382 }
3383
3384
3385 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3386 PyObject *resultobj;
3387 long result;
3388 char *kwnames[] = {
3389 NULL
3390 };
3391
3392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3393 {
3394 PyThreadState* __tstate = wxPyBeginAllowThreads();
3395 result = (long)wxNewId();
3396
3397 wxPyEndAllowThreads(__tstate);
3398 if (PyErr_Occurred()) SWIG_fail;
3399 }
3400 {
3401 resultobj = SWIG_From_long((long)(result));
3402 }
3403 return resultobj;
3404 fail:
3405 return NULL;
3406 }
3407
3408
3409 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3410 PyObject *resultobj;
3411 long arg1 ;
3412 PyObject * obj0 = 0 ;
3413 char *kwnames[] = {
3414 (char *) "id", NULL
3415 };
3416
3417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3418 {
3419 arg1 = (long)(SWIG_As_long(obj0));
3420 if (SWIG_arg_fail(1)) SWIG_fail;
3421 }
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 wxRegisterId(arg1);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 Py_INCREF(Py_None); resultobj = Py_None;
3430 return resultobj;
3431 fail:
3432 return NULL;
3433 }
3434
3435
3436 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3437 PyObject *resultobj;
3438 long result;
3439 char *kwnames[] = {
3440 NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3444 {
3445 PyThreadState* __tstate = wxPyBeginAllowThreads();
3446 result = (long)wxGetCurrentId();
3447
3448 wxPyEndAllowThreads(__tstate);
3449 if (PyErr_Occurred()) SWIG_fail;
3450 }
3451 {
3452 resultobj = SWIG_From_long((long)(result));
3453 }
3454 return resultobj;
3455 fail:
3456 return NULL;
3457 }
3458
3459
3460 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3461 PyObject *resultobj;
3462 int arg1 ;
3463 bool result;
3464 PyObject * obj0 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "id", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3470 {
3471 arg1 = (int)(SWIG_As_int(obj0));
3472 if (SWIG_arg_fail(1)) SWIG_fail;
3473 }
3474 {
3475 PyThreadState* __tstate = wxPyBeginAllowThreads();
3476 result = (bool)wxIsStockID(arg1);
3477
3478 wxPyEndAllowThreads(__tstate);
3479 if (PyErr_Occurred()) SWIG_fail;
3480 }
3481 {
3482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3483 }
3484 return resultobj;
3485 fail:
3486 return NULL;
3487 }
3488
3489
3490 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3491 PyObject *resultobj;
3492 int arg1 ;
3493 wxString *arg2 = 0 ;
3494 bool result;
3495 bool temp2 = false ;
3496 PyObject * obj0 = 0 ;
3497 PyObject * obj1 = 0 ;
3498 char *kwnames[] = {
3499 (char *) "id",(char *) "label", NULL
3500 };
3501
3502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3503 {
3504 arg1 = (int)(SWIG_As_int(obj0));
3505 if (SWIG_arg_fail(1)) SWIG_fail;
3506 }
3507 {
3508 arg2 = wxString_in_helper(obj1);
3509 if (arg2 == NULL) SWIG_fail;
3510 temp2 = true;
3511 }
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 {
3520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3521 }
3522 {
3523 if (temp2)
3524 delete arg2;
3525 }
3526 return resultobj;
3527 fail:
3528 {
3529 if (temp2)
3530 delete arg2;
3531 }
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 int arg1 ;
3539 bool arg2 = (bool) true ;
3540 wxString arg3 = (wxString) wxPyEmptyString ;
3541 wxString result;
3542 PyObject * obj0 = 0 ;
3543 PyObject * obj1 = 0 ;
3544 PyObject * obj2 = 0 ;
3545 char *kwnames[] = {
3546 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3547 };
3548
3549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3550 {
3551 arg1 = (int)(SWIG_As_int(obj0));
3552 if (SWIG_arg_fail(1)) SWIG_fail;
3553 }
3554 if (obj1) {
3555 {
3556 arg2 = (bool)(SWIG_As_bool(obj1));
3557 if (SWIG_arg_fail(2)) SWIG_fail;
3558 }
3559 }
3560 if (obj2) {
3561 {
3562 wxString* sptr = wxString_in_helper(obj2);
3563 if (sptr == NULL) SWIG_fail;
3564 arg3 = *sptr;
3565 delete sptr;
3566 }
3567 }
3568 {
3569 PyThreadState* __tstate = wxPyBeginAllowThreads();
3570 result = wxGetStockLabel(arg1,arg2,arg3);
3571
3572 wxPyEndAllowThreads(__tstate);
3573 if (PyErr_Occurred()) SWIG_fail;
3574 }
3575 {
3576 #if wxUSE_UNICODE
3577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3578 #else
3579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3580 #endif
3581 }
3582 return resultobj;
3583 fail:
3584 return NULL;
3585 }
3586
3587
3588 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3589 PyObject *resultobj;
3590 char *kwnames[] = {
3591 NULL
3592 };
3593
3594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3595 {
3596 if (!wxPyCheckForApp()) SWIG_fail;
3597 PyThreadState* __tstate = wxPyBeginAllowThreads();
3598 wxBell();
3599
3600 wxPyEndAllowThreads(__tstate);
3601 if (PyErr_Occurred()) SWIG_fail;
3602 }
3603 Py_INCREF(Py_None); resultobj = Py_None;
3604 return resultobj;
3605 fail:
3606 return NULL;
3607 }
3608
3609
3610 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3611 PyObject *resultobj;
3612 char *kwnames[] = {
3613 NULL
3614 };
3615
3616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3617 {
3618 if (!wxPyCheckForApp()) SWIG_fail;
3619 PyThreadState* __tstate = wxPyBeginAllowThreads();
3620 wxEndBusyCursor();
3621
3622 wxPyEndAllowThreads(__tstate);
3623 if (PyErr_Occurred()) SWIG_fail;
3624 }
3625 Py_INCREF(Py_None); resultobj = Py_None;
3626 return resultobj;
3627 fail:
3628 return NULL;
3629 }
3630
3631
3632 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3633 PyObject *resultobj;
3634 bool arg1 = (bool) true ;
3635 long result;
3636 PyObject * obj0 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "resetTimer", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3642 if (obj0) {
3643 {
3644 arg1 = (bool)(SWIG_As_bool(obj0));
3645 if (SWIG_arg_fail(1)) SWIG_fail;
3646 }
3647 }
3648 {
3649 PyThreadState* __tstate = wxPyBeginAllowThreads();
3650 result = (long)wxGetElapsedTime(arg1);
3651
3652 wxPyEndAllowThreads(__tstate);
3653 if (PyErr_Occurred()) SWIG_fail;
3654 }
3655 {
3656 resultobj = SWIG_From_long((long)(result));
3657 }
3658 return resultobj;
3659 fail:
3660 return NULL;
3661 }
3662
3663
3664 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3665 PyObject *resultobj;
3666 int *arg1 = (int *) 0 ;
3667 int *arg2 = (int *) 0 ;
3668 int temp1 ;
3669 int res1 = 0 ;
3670 int temp2 ;
3671 int res2 = 0 ;
3672 char *kwnames[] = {
3673 NULL
3674 };
3675
3676 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3677 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3679 {
3680 if (!wxPyCheckForApp()) SWIG_fail;
3681 PyThreadState* __tstate = wxPyBeginAllowThreads();
3682 wxGetMousePosition(arg1,arg2);
3683
3684 wxPyEndAllowThreads(__tstate);
3685 if (PyErr_Occurred()) SWIG_fail;
3686 }
3687 Py_INCREF(Py_None); resultobj = Py_None;
3688 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3689 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3690 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3691 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3692 return resultobj;
3693 fail:
3694 return NULL;
3695 }
3696
3697
3698 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3699 PyObject *resultobj;
3700 bool result;
3701 char *kwnames[] = {
3702 NULL
3703 };
3704
3705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3706 {
3707 PyThreadState* __tstate = wxPyBeginAllowThreads();
3708 result = (bool)wxIsBusy();
3709
3710 wxPyEndAllowThreads(__tstate);
3711 if (PyErr_Occurred()) SWIG_fail;
3712 }
3713 {
3714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3715 }
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxString result;
3725 char *kwnames[] = {
3726 NULL
3727 };
3728
3729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3730 {
3731 PyThreadState* __tstate = wxPyBeginAllowThreads();
3732 result = wxNow();
3733
3734 wxPyEndAllowThreads(__tstate);
3735 if (PyErr_Occurred()) SWIG_fail;
3736 }
3737 {
3738 #if wxUSE_UNICODE
3739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3740 #else
3741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3742 #endif
3743 }
3744 return resultobj;
3745 fail:
3746 return NULL;
3747 }
3748
3749
3750 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3751 PyObject *resultobj;
3752 wxString const &arg1_defvalue = wxPyEmptyString ;
3753 wxString *arg1 = (wxString *) &arg1_defvalue ;
3754 bool result;
3755 bool temp1 = false ;
3756 PyObject * obj0 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "command", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3762 if (obj0) {
3763 {
3764 arg1 = wxString_in_helper(obj0);
3765 if (arg1 == NULL) SWIG_fail;
3766 temp1 = true;
3767 }
3768 }
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (bool)wxShell((wxString const &)*arg1);
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3778 }
3779 {
3780 if (temp1)
3781 delete arg1;
3782 }
3783 return resultobj;
3784 fail:
3785 {
3786 if (temp1)
3787 delete arg1;
3788 }
3789 return NULL;
3790 }
3791
3792
3793 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3794 PyObject *resultobj;
3795 char *kwnames[] = {
3796 NULL
3797 };
3798
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3800 {
3801 PyThreadState* __tstate = wxPyBeginAllowThreads();
3802 wxStartTimer();
3803
3804 wxPyEndAllowThreads(__tstate);
3805 if (PyErr_Occurred()) SWIG_fail;
3806 }
3807 Py_INCREF(Py_None); resultobj = Py_None;
3808 return resultobj;
3809 fail:
3810 return NULL;
3811 }
3812
3813
3814 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3815 PyObject *resultobj;
3816 int *arg1 = (int *) 0 ;
3817 int *arg2 = (int *) 0 ;
3818 int result;
3819 int temp1 ;
3820 int res1 = 0 ;
3821 int temp2 ;
3822 int res2 = 0 ;
3823 char *kwnames[] = {
3824 NULL
3825 };
3826
3827 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3828 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 result = (int)wxGetOsVersion(arg1,arg2);
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 {
3838 resultobj = SWIG_From_int((int)(result));
3839 }
3840 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3841 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3842 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3843 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3844 return resultobj;
3845 fail:
3846 return NULL;
3847 }
3848
3849
3850 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3851 PyObject *resultobj;
3852 wxString result;
3853 char *kwnames[] = {
3854 NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 result = wxGetOsDescription();
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 {
3866 #if wxUSE_UNICODE
3867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3868 #else
3869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3870 #endif
3871 }
3872 return resultobj;
3873 fail:
3874 return NULL;
3875 }
3876
3877
3878 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3879 PyObject *resultobj;
3880 long result;
3881 char *kwnames[] = {
3882 NULL
3883 };
3884
3885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3886 {
3887 PyThreadState* __tstate = wxPyBeginAllowThreads();
3888 result = (long)wxGetFreeMemory();
3889
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 {
3894 resultobj = SWIG_From_long((long)(result));
3895 }
3896 return resultobj;
3897 fail:
3898 return NULL;
3899 }
3900
3901
3902 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3903 PyObject *resultobj;
3904 wxShutdownFlags arg1 ;
3905 bool result;
3906 PyObject * obj0 = 0 ;
3907 char *kwnames[] = {
3908 (char *) "wFlags", NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3912 {
3913 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3914 if (SWIG_arg_fail(1)) SWIG_fail;
3915 }
3916 {
3917 if (!wxPyCheckForApp()) SWIG_fail;
3918 PyThreadState* __tstate = wxPyBeginAllowThreads();
3919 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3920
3921 wxPyEndAllowThreads(__tstate);
3922 if (PyErr_Occurred()) SWIG_fail;
3923 }
3924 {
3925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3926 }
3927 return resultobj;
3928 fail:
3929 return NULL;
3930 }
3931
3932
3933 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3934 PyObject *resultobj;
3935 int arg1 ;
3936 PyObject * obj0 = 0 ;
3937 char *kwnames[] = {
3938 (char *) "secs", NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3942 {
3943 arg1 = (int)(SWIG_As_int(obj0));
3944 if (SWIG_arg_fail(1)) SWIG_fail;
3945 }
3946 {
3947 PyThreadState* __tstate = wxPyBeginAllowThreads();
3948 wxSleep(arg1);
3949
3950 wxPyEndAllowThreads(__tstate);
3951 if (PyErr_Occurred()) SWIG_fail;
3952 }
3953 Py_INCREF(Py_None); resultobj = Py_None;
3954 return resultobj;
3955 fail:
3956 return NULL;
3957 }
3958
3959
3960 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3961 PyObject *resultobj;
3962 unsigned long arg1 ;
3963 PyObject * obj0 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "milliseconds", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3969 {
3970 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3971 if (SWIG_arg_fail(1)) SWIG_fail;
3972 }
3973 {
3974 PyThreadState* __tstate = wxPyBeginAllowThreads();
3975 wxMilliSleep(arg1);
3976
3977 wxPyEndAllowThreads(__tstate);
3978 if (PyErr_Occurred()) SWIG_fail;
3979 }
3980 Py_INCREF(Py_None); resultobj = Py_None;
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj;
3989 unsigned long arg1 ;
3990 PyObject * obj0 = 0 ;
3991 char *kwnames[] = {
3992 (char *) "microseconds", NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3996 {
3997 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3998 if (SWIG_arg_fail(1)) SWIG_fail;
3999 }
4000 {
4001 PyThreadState* __tstate = wxPyBeginAllowThreads();
4002 wxMicroSleep(arg1);
4003
4004 wxPyEndAllowThreads(__tstate);
4005 if (PyErr_Occurred()) SWIG_fail;
4006 }
4007 Py_INCREF(Py_None); resultobj = Py_None;
4008 return resultobj;
4009 fail:
4010 return NULL;
4011 }
4012
4013
4014 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4015 PyObject *resultobj;
4016 bool arg1 ;
4017 PyObject * obj0 = 0 ;
4018 char *kwnames[] = {
4019 (char *) "enable", NULL
4020 };
4021
4022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4023 {
4024 arg1 = (bool)(SWIG_As_bool(obj0));
4025 if (SWIG_arg_fail(1)) SWIG_fail;
4026 }
4027 {
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 wxEnableTopLevelWindows(arg1);
4030
4031 wxPyEndAllowThreads(__tstate);
4032 if (PyErr_Occurred()) SWIG_fail;
4033 }
4034 Py_INCREF(Py_None); resultobj = Py_None;
4035 return resultobj;
4036 fail:
4037 return NULL;
4038 }
4039
4040
4041 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4042 PyObject *resultobj;
4043 wxString *arg1 = 0 ;
4044 wxString result;
4045 bool temp1 = false ;
4046 PyObject * obj0 = 0 ;
4047 char *kwnames[] = {
4048 (char *) "in", NULL
4049 };
4050
4051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4052 {
4053 arg1 = wxString_in_helper(obj0);
4054 if (arg1 == NULL) SWIG_fail;
4055 temp1 = true;
4056 }
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = wxStripMenuCodes((wxString const &)*arg1);
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 {
4065 #if wxUSE_UNICODE
4066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4067 #else
4068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4069 #endif
4070 }
4071 {
4072 if (temp1)
4073 delete arg1;
4074 }
4075 return resultobj;
4076 fail:
4077 {
4078 if (temp1)
4079 delete arg1;
4080 }
4081 return NULL;
4082 }
4083
4084
4085 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4086 PyObject *resultobj;
4087 wxString result;
4088 char *kwnames[] = {
4089 NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4093 {
4094 PyThreadState* __tstate = wxPyBeginAllowThreads();
4095 result = wxGetEmailAddress();
4096
4097 wxPyEndAllowThreads(__tstate);
4098 if (PyErr_Occurred()) SWIG_fail;
4099 }
4100 {
4101 #if wxUSE_UNICODE
4102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4103 #else
4104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4105 #endif
4106 }
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxString result;
4116 char *kwnames[] = {
4117 NULL
4118 };
4119
4120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = wxGetHostName();
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 {
4129 #if wxUSE_UNICODE
4130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4131 #else
4132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4133 #endif
4134 }
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxString result;
4144 char *kwnames[] = {
4145 NULL
4146 };
4147
4148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4149 {
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = wxGetFullHostName();
4152
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 {
4157 #if wxUSE_UNICODE
4158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4159 #else
4160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4161 #endif
4162 }
4163 return resultobj;
4164 fail:
4165 return NULL;
4166 }
4167
4168
4169 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4170 PyObject *resultobj;
4171 wxString result;
4172 char *kwnames[] = {
4173 NULL
4174 };
4175
4176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4177 {
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = wxGetUserId();
4180
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 {
4185 #if wxUSE_UNICODE
4186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4187 #else
4188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4189 #endif
4190 }
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj;
4199 wxString result;
4200 char *kwnames[] = {
4201 NULL
4202 };
4203
4204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = wxGetUserName();
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 #if wxUSE_UNICODE
4214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4215 #else
4216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4217 #endif
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxString result;
4228 char *kwnames[] = {
4229 NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4233 {
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = wxGetHomeDir();
4236
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 {
4241 #if wxUSE_UNICODE
4242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4243 #else
4244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4245 #endif
4246 }
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxString const &arg1_defvalue = wxPyEmptyString ;
4256 wxString *arg1 = (wxString *) &arg1_defvalue ;
4257 wxString result;
4258 bool temp1 = false ;
4259 PyObject * obj0 = 0 ;
4260 char *kwnames[] = {
4261 (char *) "user", NULL
4262 };
4263
4264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4265 if (obj0) {
4266 {
4267 arg1 = wxString_in_helper(obj0);
4268 if (arg1 == NULL) SWIG_fail;
4269 temp1 = true;
4270 }
4271 }
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 result = wxGetUserHome((wxString const &)*arg1);
4275
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 {
4280 #if wxUSE_UNICODE
4281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4282 #else
4283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4284 #endif
4285 }
4286 {
4287 if (temp1)
4288 delete arg1;
4289 }
4290 return resultobj;
4291 fail:
4292 {
4293 if (temp1)
4294 delete arg1;
4295 }
4296 return NULL;
4297 }
4298
4299
4300 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj;
4302 unsigned long result;
4303 char *kwnames[] = {
4304 NULL
4305 };
4306
4307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = (unsigned long)wxGetProcessId();
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 {
4316 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4317 }
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj;
4326 char *kwnames[] = {
4327 NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4331 {
4332 PyThreadState* __tstate = wxPyBeginAllowThreads();
4333 wxTrap();
4334
4335 wxPyEndAllowThreads(__tstate);
4336 if (PyErr_Occurred()) SWIG_fail;
4337 }
4338 Py_INCREF(Py_None); resultobj = Py_None;
4339 return resultobj;
4340 fail:
4341 return NULL;
4342 }
4343
4344
4345 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4346 PyObject *resultobj;
4347 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4348 wxString *arg1 = (wxString *) &arg1_defvalue ;
4349 wxString const &arg2_defvalue = wxPyEmptyString ;
4350 wxString *arg2 = (wxString *) &arg2_defvalue ;
4351 wxString const &arg3_defvalue = wxPyEmptyString ;
4352 wxString *arg3 = (wxString *) &arg3_defvalue ;
4353 wxString const &arg4_defvalue = wxPyEmptyString ;
4354 wxString *arg4 = (wxString *) &arg4_defvalue ;
4355 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4356 wxString *arg5 = (wxString *) &arg5_defvalue ;
4357 int arg6 = (int) 0 ;
4358 wxWindow *arg7 = (wxWindow *) NULL ;
4359 int arg8 = (int) -1 ;
4360 int arg9 = (int) -1 ;
4361 wxString result;
4362 bool temp1 = false ;
4363 bool temp2 = false ;
4364 bool temp3 = false ;
4365 bool temp4 = false ;
4366 bool temp5 = false ;
4367 PyObject * obj0 = 0 ;
4368 PyObject * obj1 = 0 ;
4369 PyObject * obj2 = 0 ;
4370 PyObject * obj3 = 0 ;
4371 PyObject * obj4 = 0 ;
4372 PyObject * obj5 = 0 ;
4373 PyObject * obj6 = 0 ;
4374 PyObject * obj7 = 0 ;
4375 PyObject * obj8 = 0 ;
4376 char *kwnames[] = {
4377 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4378 };
4379
4380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4381 if (obj0) {
4382 {
4383 arg1 = wxString_in_helper(obj0);
4384 if (arg1 == NULL) SWIG_fail;
4385 temp1 = true;
4386 }
4387 }
4388 if (obj1) {
4389 {
4390 arg2 = wxString_in_helper(obj1);
4391 if (arg2 == NULL) SWIG_fail;
4392 temp2 = true;
4393 }
4394 }
4395 if (obj2) {
4396 {
4397 arg3 = wxString_in_helper(obj2);
4398 if (arg3 == NULL) SWIG_fail;
4399 temp3 = true;
4400 }
4401 }
4402 if (obj3) {
4403 {
4404 arg4 = wxString_in_helper(obj3);
4405 if (arg4 == NULL) SWIG_fail;
4406 temp4 = true;
4407 }
4408 }
4409 if (obj4) {
4410 {
4411 arg5 = wxString_in_helper(obj4);
4412 if (arg5 == NULL) SWIG_fail;
4413 temp5 = true;
4414 }
4415 }
4416 if (obj5) {
4417 {
4418 arg6 = (int)(SWIG_As_int(obj5));
4419 if (SWIG_arg_fail(6)) SWIG_fail;
4420 }
4421 }
4422 if (obj6) {
4423 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4424 if (SWIG_arg_fail(7)) SWIG_fail;
4425 }
4426 if (obj7) {
4427 {
4428 arg8 = (int)(SWIG_As_int(obj7));
4429 if (SWIG_arg_fail(8)) SWIG_fail;
4430 }
4431 }
4432 if (obj8) {
4433 {
4434 arg9 = (int)(SWIG_As_int(obj8));
4435 if (SWIG_arg_fail(9)) SWIG_fail;
4436 }
4437 }
4438 {
4439 if (!wxPyCheckForApp()) SWIG_fail;
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4442
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 {
4447 #if wxUSE_UNICODE
4448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4449 #else
4450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4451 #endif
4452 }
4453 {
4454 if (temp1)
4455 delete arg1;
4456 }
4457 {
4458 if (temp2)
4459 delete arg2;
4460 }
4461 {
4462 if (temp3)
4463 delete arg3;
4464 }
4465 {
4466 if (temp4)
4467 delete arg4;
4468 }
4469 {
4470 if (temp5)
4471 delete arg5;
4472 }
4473 return resultobj;
4474 fail:
4475 {
4476 if (temp1)
4477 delete arg1;
4478 }
4479 {
4480 if (temp2)
4481 delete arg2;
4482 }
4483 {
4484 if (temp3)
4485 delete arg3;
4486 }
4487 {
4488 if (temp4)
4489 delete arg4;
4490 }
4491 {
4492 if (temp5)
4493 delete arg5;
4494 }
4495 return NULL;
4496 }
4497
4498
4499 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj;
4501 wxString *arg1 = 0 ;
4502 wxString *arg2 = 0 ;
4503 wxString const &arg3_defvalue = wxPyEmptyString ;
4504 wxString *arg3 = (wxString *) &arg3_defvalue ;
4505 wxWindow *arg4 = (wxWindow *) NULL ;
4506 wxString result;
4507 bool temp1 = false ;
4508 bool temp2 = false ;
4509 bool temp3 = false ;
4510 PyObject * obj0 = 0 ;
4511 PyObject * obj1 = 0 ;
4512 PyObject * obj2 = 0 ;
4513 PyObject * obj3 = 0 ;
4514 char *kwnames[] = {
4515 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4519 {
4520 arg1 = wxString_in_helper(obj0);
4521 if (arg1 == NULL) SWIG_fail;
4522 temp1 = true;
4523 }
4524 {
4525 arg2 = wxString_in_helper(obj1);
4526 if (arg2 == NULL) SWIG_fail;
4527 temp2 = true;
4528 }
4529 if (obj2) {
4530 {
4531 arg3 = wxString_in_helper(obj2);
4532 if (arg3 == NULL) SWIG_fail;
4533 temp3 = true;
4534 }
4535 }
4536 if (obj3) {
4537 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4538 if (SWIG_arg_fail(4)) SWIG_fail;
4539 }
4540 {
4541 if (!wxPyCheckForApp()) SWIG_fail;
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4544
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 #if wxUSE_UNICODE
4550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4551 #else
4552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4553 #endif
4554 }
4555 {
4556 if (temp1)
4557 delete arg1;
4558 }
4559 {
4560 if (temp2)
4561 delete arg2;
4562 }
4563 {
4564 if (temp3)
4565 delete arg3;
4566 }
4567 return resultobj;
4568 fail:
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 {
4574 if (temp2)
4575 delete arg2;
4576 }
4577 {
4578 if (temp3)
4579 delete arg3;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj;
4587 wxString *arg1 = 0 ;
4588 wxString *arg2 = 0 ;
4589 wxString const &arg3_defvalue = wxPyEmptyString ;
4590 wxString *arg3 = (wxString *) &arg3_defvalue ;
4591 wxWindow *arg4 = (wxWindow *) NULL ;
4592 wxString result;
4593 bool temp1 = false ;
4594 bool temp2 = false ;
4595 bool temp3 = false ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 PyObject * obj2 = 0 ;
4599 PyObject * obj3 = 0 ;
4600 char *kwnames[] = {
4601 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4602 };
4603
4604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4605 {
4606 arg1 = wxString_in_helper(obj0);
4607 if (arg1 == NULL) SWIG_fail;
4608 temp1 = true;
4609 }
4610 {
4611 arg2 = wxString_in_helper(obj1);
4612 if (arg2 == NULL) SWIG_fail;
4613 temp2 = true;
4614 }
4615 if (obj2) {
4616 {
4617 arg3 = wxString_in_helper(obj2);
4618 if (arg3 == NULL) SWIG_fail;
4619 temp3 = true;
4620 }
4621 }
4622 if (obj3) {
4623 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4624 if (SWIG_arg_fail(4)) SWIG_fail;
4625 }
4626 {
4627 if (!wxPyCheckForApp()) SWIG_fail;
4628 PyThreadState* __tstate = wxPyBeginAllowThreads();
4629 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4630
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 #if wxUSE_UNICODE
4636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4637 #else
4638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4639 #endif
4640 }
4641 {
4642 if (temp1)
4643 delete arg1;
4644 }
4645 {
4646 if (temp2)
4647 delete arg2;
4648 }
4649 {
4650 if (temp3)
4651 delete arg3;
4652 }
4653 return resultobj;
4654 fail:
4655 {
4656 if (temp1)
4657 delete arg1;
4658 }
4659 {
4660 if (temp2)
4661 delete arg2;
4662 }
4663 {
4664 if (temp3)
4665 delete arg3;
4666 }
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj;
4673 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4674 wxString *arg1 = (wxString *) &arg1_defvalue ;
4675 wxString const &arg2_defvalue = wxPyEmptyString ;
4676 wxString *arg2 = (wxString *) &arg2_defvalue ;
4677 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4678 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4679 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4680 wxWindow *arg5 = (wxWindow *) NULL ;
4681 wxString result;
4682 bool temp1 = false ;
4683 bool temp2 = false ;
4684 wxPoint temp4 ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 PyObject * obj2 = 0 ;
4688 PyObject * obj3 = 0 ;
4689 PyObject * obj4 = 0 ;
4690 char *kwnames[] = {
4691 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4692 };
4693
4694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4695 if (obj0) {
4696 {
4697 arg1 = wxString_in_helper(obj0);
4698 if (arg1 == NULL) SWIG_fail;
4699 temp1 = true;
4700 }
4701 }
4702 if (obj1) {
4703 {
4704 arg2 = wxString_in_helper(obj1);
4705 if (arg2 == NULL) SWIG_fail;
4706 temp2 = true;
4707 }
4708 }
4709 if (obj2) {
4710 {
4711 arg3 = (long)(SWIG_As_long(obj2));
4712 if (SWIG_arg_fail(3)) SWIG_fail;
4713 }
4714 }
4715 if (obj3) {
4716 {
4717 arg4 = &temp4;
4718 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4719 }
4720 }
4721 if (obj4) {
4722 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4723 if (SWIG_arg_fail(5)) SWIG_fail;
4724 }
4725 {
4726 if (!wxPyCheckForApp()) SWIG_fail;
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4729
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 {
4734 #if wxUSE_UNICODE
4735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4736 #else
4737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4738 #endif
4739 }
4740 {
4741 if (temp1)
4742 delete arg1;
4743 }
4744 {
4745 if (temp2)
4746 delete arg2;
4747 }
4748 return resultobj;
4749 fail:
4750 {
4751 if (temp1)
4752 delete arg1;
4753 }
4754 {
4755 if (temp2)
4756 delete arg2;
4757 }
4758 return NULL;
4759 }
4760
4761
4762 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj;
4764 wxString *arg1 = 0 ;
4765 wxString const &arg2_defvalue = wxPyEmptyString ;
4766 wxString *arg2 = (wxString *) &arg2_defvalue ;
4767 wxString const &arg3_defvalue = wxPyEmptyString ;
4768 wxString *arg3 = (wxString *) &arg3_defvalue ;
4769 wxWindow *arg4 = (wxWindow *) NULL ;
4770 int arg5 = (int) -1 ;
4771 int arg6 = (int) -1 ;
4772 bool arg7 = (bool) true ;
4773 wxString result;
4774 bool temp1 = false ;
4775 bool temp2 = false ;
4776 bool temp3 = false ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 PyObject * obj2 = 0 ;
4780 PyObject * obj3 = 0 ;
4781 PyObject * obj4 = 0 ;
4782 PyObject * obj5 = 0 ;
4783 PyObject * obj6 = 0 ;
4784 char *kwnames[] = {
4785 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4786 };
4787
4788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4789 {
4790 arg1 = wxString_in_helper(obj0);
4791 if (arg1 == NULL) SWIG_fail;
4792 temp1 = true;
4793 }
4794 if (obj1) {
4795 {
4796 arg2 = wxString_in_helper(obj1);
4797 if (arg2 == NULL) SWIG_fail;
4798 temp2 = true;
4799 }
4800 }
4801 if (obj2) {
4802 {
4803 arg3 = wxString_in_helper(obj2);
4804 if (arg3 == NULL) SWIG_fail;
4805 temp3 = true;
4806 }
4807 }
4808 if (obj3) {
4809 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4810 if (SWIG_arg_fail(4)) SWIG_fail;
4811 }
4812 if (obj4) {
4813 {
4814 arg5 = (int)(SWIG_As_int(obj4));
4815 if (SWIG_arg_fail(5)) SWIG_fail;
4816 }
4817 }
4818 if (obj5) {
4819 {
4820 arg6 = (int)(SWIG_As_int(obj5));
4821 if (SWIG_arg_fail(6)) SWIG_fail;
4822 }
4823 }
4824 if (obj6) {
4825 {
4826 arg7 = (bool)(SWIG_As_bool(obj6));
4827 if (SWIG_arg_fail(7)) SWIG_fail;
4828 }
4829 }
4830 {
4831 if (!wxPyCheckForApp()) SWIG_fail;
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4834
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 {
4839 #if wxUSE_UNICODE
4840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4841 #else
4842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4843 #endif
4844 }
4845 {
4846 if (temp1)
4847 delete arg1;
4848 }
4849 {
4850 if (temp2)
4851 delete arg2;
4852 }
4853 {
4854 if (temp3)
4855 delete arg3;
4856 }
4857 return resultobj;
4858 fail:
4859 {
4860 if (temp1)
4861 delete arg1;
4862 }
4863 {
4864 if (temp2)
4865 delete arg2;
4866 }
4867 {
4868 if (temp3)
4869 delete arg3;
4870 }
4871 return NULL;
4872 }
4873
4874
4875 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4876 PyObject *resultobj;
4877 wxString *arg1 = 0 ;
4878 wxString const &arg2_defvalue = wxPyEmptyString ;
4879 wxString *arg2 = (wxString *) &arg2_defvalue ;
4880 wxString const &arg3_defvalue = wxPyEmptyString ;
4881 wxString *arg3 = (wxString *) &arg3_defvalue ;
4882 wxWindow *arg4 = (wxWindow *) NULL ;
4883 wxString result;
4884 bool temp1 = false ;
4885 bool temp2 = false ;
4886 bool temp3 = false ;
4887 PyObject * obj0 = 0 ;
4888 PyObject * obj1 = 0 ;
4889 PyObject * obj2 = 0 ;
4890 PyObject * obj3 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4896 {
4897 arg1 = wxString_in_helper(obj0);
4898 if (arg1 == NULL) SWIG_fail;
4899 temp1 = true;
4900 }
4901 if (obj1) {
4902 {
4903 arg2 = wxString_in_helper(obj1);
4904 if (arg2 == NULL) SWIG_fail;
4905 temp2 = true;
4906 }
4907 }
4908 if (obj2) {
4909 {
4910 arg3 = wxString_in_helper(obj2);
4911 if (arg3 == NULL) SWIG_fail;
4912 temp3 = true;
4913 }
4914 }
4915 if (obj3) {
4916 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4917 if (SWIG_arg_fail(4)) SWIG_fail;
4918 }
4919 {
4920 if (!wxPyCheckForApp()) SWIG_fail;
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 #if wxUSE_UNICODE
4929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4930 #else
4931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4932 #endif
4933 }
4934 {
4935 if (temp1)
4936 delete arg1;
4937 }
4938 {
4939 if (temp2)
4940 delete arg2;
4941 }
4942 {
4943 if (temp3)
4944 delete arg3;
4945 }
4946 return resultobj;
4947 fail:
4948 {
4949 if (temp1)
4950 delete arg1;
4951 }
4952 {
4953 if (temp2)
4954 delete arg2;
4955 }
4956 {
4957 if (temp3)
4958 delete arg3;
4959 }
4960 return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj;
4966 wxString *arg1 = 0 ;
4967 wxString *arg2 = 0 ;
4968 int arg3 ;
4969 wxString *arg4 = (wxString *) 0 ;
4970 wxWindow *arg5 = (wxWindow *) NULL ;
4971 int arg6 = (int) -1 ;
4972 int arg7 = (int) -1 ;
4973 bool arg8 = (bool) true ;
4974 int arg9 = (int) 150 ;
4975 int arg10 = (int) 200 ;
4976 wxString result;
4977 bool temp1 = false ;
4978 bool temp2 = false ;
4979 PyObject * obj0 = 0 ;
4980 PyObject * obj1 = 0 ;
4981 PyObject * obj2 = 0 ;
4982 PyObject * obj3 = 0 ;
4983 PyObject * obj4 = 0 ;
4984 PyObject * obj5 = 0 ;
4985 PyObject * obj6 = 0 ;
4986 PyObject * obj7 = 0 ;
4987 PyObject * obj8 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4993 {
4994 arg1 = wxString_in_helper(obj0);
4995 if (arg1 == NULL) SWIG_fail;
4996 temp1 = true;
4997 }
4998 {
4999 arg2 = wxString_in_helper(obj1);
5000 if (arg2 == NULL) SWIG_fail;
5001 temp2 = true;
5002 }
5003 {
5004 arg3 = PyList_Size(obj2);
5005 arg4 = wxString_LIST_helper(obj2);
5006 if (arg4 == NULL) SWIG_fail;
5007 }
5008 if (obj3) {
5009 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5010 if (SWIG_arg_fail(5)) SWIG_fail;
5011 }
5012 if (obj4) {
5013 {
5014 arg6 = (int)(SWIG_As_int(obj4));
5015 if (SWIG_arg_fail(6)) SWIG_fail;
5016 }
5017 }
5018 if (obj5) {
5019 {
5020 arg7 = (int)(SWIG_As_int(obj5));
5021 if (SWIG_arg_fail(7)) SWIG_fail;
5022 }
5023 }
5024 if (obj6) {
5025 {
5026 arg8 = (bool)(SWIG_As_bool(obj6));
5027 if (SWIG_arg_fail(8)) SWIG_fail;
5028 }
5029 }
5030 if (obj7) {
5031 {
5032 arg9 = (int)(SWIG_As_int(obj7));
5033 if (SWIG_arg_fail(9)) SWIG_fail;
5034 }
5035 }
5036 if (obj8) {
5037 {
5038 arg10 = (int)(SWIG_As_int(obj8));
5039 if (SWIG_arg_fail(10)) SWIG_fail;
5040 }
5041 }
5042 {
5043 if (!wxPyCheckForApp()) SWIG_fail;
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5046
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 #if wxUSE_UNICODE
5052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5053 #else
5054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5055 #endif
5056 }
5057 {
5058 if (temp1)
5059 delete arg1;
5060 }
5061 {
5062 if (temp2)
5063 delete arg2;
5064 }
5065 {
5066 if (arg4) delete [] arg4;
5067 }
5068 return resultobj;
5069 fail:
5070 {
5071 if (temp1)
5072 delete arg1;
5073 }
5074 {
5075 if (temp2)
5076 delete arg2;
5077 }
5078 {
5079 if (arg4) delete [] arg4;
5080 }
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxString *arg1 = 0 ;
5088 wxString *arg2 = 0 ;
5089 int arg3 ;
5090 wxString *arg4 = (wxString *) 0 ;
5091 wxWindow *arg5 = (wxWindow *) NULL ;
5092 int arg6 = (int) -1 ;
5093 int arg7 = (int) -1 ;
5094 bool arg8 = (bool) true ;
5095 int arg9 = (int) 150 ;
5096 int arg10 = (int) 200 ;
5097 int result;
5098 bool temp1 = false ;
5099 bool temp2 = false ;
5100 PyObject * obj0 = 0 ;
5101 PyObject * obj1 = 0 ;
5102 PyObject * obj2 = 0 ;
5103 PyObject * obj3 = 0 ;
5104 PyObject * obj4 = 0 ;
5105 PyObject * obj5 = 0 ;
5106 PyObject * obj6 = 0 ;
5107 PyObject * obj7 = 0 ;
5108 PyObject * obj8 = 0 ;
5109 char *kwnames[] = {
5110 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5111 };
5112
5113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5114 {
5115 arg1 = wxString_in_helper(obj0);
5116 if (arg1 == NULL) SWIG_fail;
5117 temp1 = true;
5118 }
5119 {
5120 arg2 = wxString_in_helper(obj1);
5121 if (arg2 == NULL) SWIG_fail;
5122 temp2 = true;
5123 }
5124 {
5125 arg3 = PyList_Size(obj2);
5126 arg4 = wxString_LIST_helper(obj2);
5127 if (arg4 == NULL) SWIG_fail;
5128 }
5129 if (obj3) {
5130 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5131 if (SWIG_arg_fail(5)) SWIG_fail;
5132 }
5133 if (obj4) {
5134 {
5135 arg6 = (int)(SWIG_As_int(obj4));
5136 if (SWIG_arg_fail(6)) SWIG_fail;
5137 }
5138 }
5139 if (obj5) {
5140 {
5141 arg7 = (int)(SWIG_As_int(obj5));
5142 if (SWIG_arg_fail(7)) SWIG_fail;
5143 }
5144 }
5145 if (obj6) {
5146 {
5147 arg8 = (bool)(SWIG_As_bool(obj6));
5148 if (SWIG_arg_fail(8)) SWIG_fail;
5149 }
5150 }
5151 if (obj7) {
5152 {
5153 arg9 = (int)(SWIG_As_int(obj7));
5154 if (SWIG_arg_fail(9)) SWIG_fail;
5155 }
5156 }
5157 if (obj8) {
5158 {
5159 arg10 = (int)(SWIG_As_int(obj8));
5160 if (SWIG_arg_fail(10)) SWIG_fail;
5161 }
5162 }
5163 {
5164 if (!wxPyCheckForApp()) SWIG_fail;
5165 PyThreadState* __tstate = wxPyBeginAllowThreads();
5166 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5167
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 resultobj = SWIG_From_int((int)(result));
5173 }
5174 {
5175 if (temp1)
5176 delete arg1;
5177 }
5178 {
5179 if (temp2)
5180 delete arg2;
5181 }
5182 {
5183 if (arg4) delete [] arg4;
5184 }
5185 return resultobj;
5186 fail:
5187 {
5188 if (temp1)
5189 delete arg1;
5190 }
5191 {
5192 if (temp2)
5193 delete arg2;
5194 }
5195 {
5196 if (arg4) delete [] arg4;
5197 }
5198 return NULL;
5199 }
5200
5201
5202 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5203 PyObject *resultobj;
5204 wxString *arg1 = 0 ;
5205 wxString const &arg2_defvalue = wxPyEmptyString ;
5206 wxString *arg2 = (wxString *) &arg2_defvalue ;
5207 int arg3 = (int) wxOK|wxCENTRE ;
5208 wxWindow *arg4 = (wxWindow *) NULL ;
5209 int arg5 = (int) -1 ;
5210 int arg6 = (int) -1 ;
5211 int result;
5212 bool temp1 = false ;
5213 bool temp2 = false ;
5214 PyObject * obj0 = 0 ;
5215 PyObject * obj1 = 0 ;
5216 PyObject * obj2 = 0 ;
5217 PyObject * obj3 = 0 ;
5218 PyObject * obj4 = 0 ;
5219 PyObject * obj5 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5225 {
5226 arg1 = wxString_in_helper(obj0);
5227 if (arg1 == NULL) SWIG_fail;
5228 temp1 = true;
5229 }
5230 if (obj1) {
5231 {
5232 arg2 = wxString_in_helper(obj1);
5233 if (arg2 == NULL) SWIG_fail;
5234 temp2 = true;
5235 }
5236 }
5237 if (obj2) {
5238 {
5239 arg3 = (int)(SWIG_As_int(obj2));
5240 if (SWIG_arg_fail(3)) SWIG_fail;
5241 }
5242 }
5243 if (obj3) {
5244 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5245 if (SWIG_arg_fail(4)) SWIG_fail;
5246 }
5247 if (obj4) {
5248 {
5249 arg5 = (int)(SWIG_As_int(obj4));
5250 if (SWIG_arg_fail(5)) SWIG_fail;
5251 }
5252 }
5253 if (obj5) {
5254 {
5255 arg6 = (int)(SWIG_As_int(obj5));
5256 if (SWIG_arg_fail(6)) SWIG_fail;
5257 }
5258 }
5259 {
5260 if (!wxPyCheckForApp()) SWIG_fail;
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5263
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 resultobj = SWIG_From_int((int)(result));
5269 }
5270 {
5271 if (temp1)
5272 delete arg1;
5273 }
5274 {
5275 if (temp2)
5276 delete arg2;
5277 }
5278 return resultobj;
5279 fail:
5280 {
5281 if (temp1)
5282 delete arg1;
5283 }
5284 {
5285 if (temp2)
5286 delete arg2;
5287 }
5288 return NULL;
5289 }
5290
5291
5292 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj;
5294 wxString *arg1 = 0 ;
5295 wxString *arg2 = 0 ;
5296 wxString *arg3 = 0 ;
5297 long arg4 ;
5298 long arg5 = (long) 0 ;
5299 long arg6 = (long) 100 ;
5300 wxWindow *arg7 = (wxWindow *) NULL ;
5301 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5302 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5303 long result;
5304 bool temp1 = false ;
5305 bool temp2 = false ;
5306 bool temp3 = false ;
5307 wxPoint temp8 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 PyObject * obj2 = 0 ;
5311 PyObject * obj3 = 0 ;
5312 PyObject * obj4 = 0 ;
5313 PyObject * obj5 = 0 ;
5314 PyObject * obj6 = 0 ;
5315 PyObject * obj7 = 0 ;
5316 char *kwnames[] = {
5317 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5318 };
5319
5320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5321 {
5322 arg1 = wxString_in_helper(obj0);
5323 if (arg1 == NULL) SWIG_fail;
5324 temp1 = true;
5325 }
5326 {
5327 arg2 = wxString_in_helper(obj1);
5328 if (arg2 == NULL) SWIG_fail;
5329 temp2 = true;
5330 }
5331 {
5332 arg3 = wxString_in_helper(obj2);
5333 if (arg3 == NULL) SWIG_fail;
5334 temp3 = true;
5335 }
5336 {
5337 arg4 = (long)(SWIG_As_long(obj3));
5338 if (SWIG_arg_fail(4)) SWIG_fail;
5339 }
5340 if (obj4) {
5341 {
5342 arg5 = (long)(SWIG_As_long(obj4));
5343 if (SWIG_arg_fail(5)) SWIG_fail;
5344 }
5345 }
5346 if (obj5) {
5347 {
5348 arg6 = (long)(SWIG_As_long(obj5));
5349 if (SWIG_arg_fail(6)) SWIG_fail;
5350 }
5351 }
5352 if (obj6) {
5353 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5354 if (SWIG_arg_fail(7)) SWIG_fail;
5355 }
5356 if (obj7) {
5357 {
5358 arg8 = &temp8;
5359 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5360 }
5361 }
5362 {
5363 if (!wxPyCheckForApp()) SWIG_fail;
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 {
5371 resultobj = SWIG_From_long((long)(result));
5372 }
5373 {
5374 if (temp1)
5375 delete arg1;
5376 }
5377 {
5378 if (temp2)
5379 delete arg2;
5380 }
5381 {
5382 if (temp3)
5383 delete arg3;
5384 }
5385 return resultobj;
5386 fail:
5387 {
5388 if (temp1)
5389 delete arg1;
5390 }
5391 {
5392 if (temp2)
5393 delete arg2;
5394 }
5395 {
5396 if (temp3)
5397 delete arg3;
5398 }
5399 return NULL;
5400 }
5401
5402
5403 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj;
5405 bool result;
5406 char *kwnames[] = {
5407 NULL
5408 };
5409
5410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5411 {
5412 if (!wxPyCheckForApp()) SWIG_fail;
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 result = (bool)wxColourDisplay();
5415
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj;
5430 int result;
5431 char *kwnames[] = {
5432 NULL
5433 };
5434
5435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5436 {
5437 if (!wxPyCheckForApp()) SWIG_fail;
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = (int)wxDisplayDepth();
5440
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 {
5445 resultobj = SWIG_From_int((int)(result));
5446 }
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5454 PyObject *resultobj;
5455 int result;
5456 char *kwnames[] = {
5457 NULL
5458 };
5459
5460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5461 {
5462 if (!wxPyCheckForApp()) SWIG_fail;
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (int)wxGetDisplayDepth();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = SWIG_From_int((int)(result));
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 int *arg1 = (int *) 0 ;
5481 int *arg2 = (int *) 0 ;
5482 int temp1 ;
5483 int res1 = 0 ;
5484 int temp2 ;
5485 int res2 = 0 ;
5486 char *kwnames[] = {
5487 NULL
5488 };
5489
5490 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5491 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5493 {
5494 if (!wxPyCheckForApp()) SWIG_fail;
5495 PyThreadState* __tstate = wxPyBeginAllowThreads();
5496 wxDisplaySize(arg1,arg2);
5497
5498 wxPyEndAllowThreads(__tstate);
5499 if (PyErr_Occurred()) SWIG_fail;
5500 }
5501 Py_INCREF(Py_None); resultobj = Py_None;
5502 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5503 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5504 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5505 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5513 PyObject *resultobj;
5514 wxSize result;
5515 char *kwnames[] = {
5516 NULL
5517 };
5518
5519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5520 {
5521 if (!wxPyCheckForApp()) SWIG_fail;
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 result = wxGetDisplaySize();
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 {
5529 wxSize * resultptr;
5530 resultptr = new wxSize((wxSize &)(result));
5531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj;
5541 int *arg1 = (int *) 0 ;
5542 int *arg2 = (int *) 0 ;
5543 int temp1 ;
5544 int res1 = 0 ;
5545 int temp2 ;
5546 int res2 = 0 ;
5547 char *kwnames[] = {
5548 NULL
5549 };
5550
5551 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5552 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5554 {
5555 if (!wxPyCheckForApp()) SWIG_fail;
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 wxDisplaySizeMM(arg1,arg2);
5558
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 Py_INCREF(Py_None); resultobj = Py_None;
5563 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5564 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5565 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5566 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj;
5575 wxSize result;
5576 char *kwnames[] = {
5577 NULL
5578 };
5579
5580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5581 {
5582 if (!wxPyCheckForApp()) SWIG_fail;
5583 PyThreadState* __tstate = wxPyBeginAllowThreads();
5584 result = wxGetDisplaySizeMM();
5585
5586 wxPyEndAllowThreads(__tstate);
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 {
5590 wxSize * resultptr;
5591 resultptr = new wxSize((wxSize &)(result));
5592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5593 }
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj;
5602 int *arg1 = (int *) 0 ;
5603 int *arg2 = (int *) 0 ;
5604 int *arg3 = (int *) 0 ;
5605 int *arg4 = (int *) 0 ;
5606 int temp1 ;
5607 int res1 = 0 ;
5608 int temp2 ;
5609 int res2 = 0 ;
5610 int temp3 ;
5611 int res3 = 0 ;
5612 int temp4 ;
5613 int res4 = 0 ;
5614 char *kwnames[] = {
5615 NULL
5616 };
5617
5618 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5619 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5620 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5621 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5623 {
5624 if (!wxPyCheckForApp()) SWIG_fail;
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5627
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 Py_INCREF(Py_None); resultobj = Py_None;
5632 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5633 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5634 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5635 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5636 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5637 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5638 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5639 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj;
5648 wxRect result;
5649 char *kwnames[] = {
5650 NULL
5651 };
5652
5653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5654 {
5655 if (!wxPyCheckForApp()) SWIG_fail;
5656 PyThreadState* __tstate = wxPyBeginAllowThreads();
5657 result = wxGetClientDisplayRect();
5658
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 {
5663 wxRect * resultptr;
5664 resultptr = new wxRect((wxRect &)(result));
5665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5666 }
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5674 PyObject *resultobj;
5675 wxCursor *arg1 = 0 ;
5676 PyObject * obj0 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "cursor", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5682 {
5683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5684 if (SWIG_arg_fail(1)) SWIG_fail;
5685 if (arg1 == NULL) {
5686 SWIG_null_ref("wxCursor");
5687 }
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 }
5690 {
5691 if (!wxPyCheckForApp()) SWIG_fail;
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 wxSetCursor(*arg1);
5694
5695 wxPyEndAllowThreads(__tstate);
5696 if (PyErr_Occurred()) SWIG_fail;
5697 }
5698 Py_INCREF(Py_None); resultobj = Py_None;
5699 return resultobj;
5700 fail:
5701 return NULL;
5702 }
5703
5704
5705 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5706 PyObject *resultobj;
5707 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5708 PyObject * obj0 = 0 ;
5709 char *kwnames[] = {
5710 (char *) "cursor", NULL
5711 };
5712
5713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5714 if (obj0) {
5715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5716 if (SWIG_arg_fail(1)) SWIG_fail;
5717 }
5718 {
5719 if (!wxPyCheckForApp()) SWIG_fail;
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 wxBeginBusyCursor(arg1);
5722
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 Py_INCREF(Py_None); resultobj = Py_None;
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxWindow *result;
5736 char *kwnames[] = {
5737 NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5741 {
5742 if (!wxPyCheckForApp()) SWIG_fail;
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 result = (wxWindow *)wxGetActiveWindow();
5745
5746 wxPyEndAllowThreads(__tstate);
5747 if (PyErr_Occurred()) SWIG_fail;
5748 }
5749 {
5750 resultobj = wxPyMake_wxObject(result, 0);
5751 }
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 wxPoint *arg1 = 0 ;
5761 wxWindow *result;
5762 wxPoint temp1 ;
5763 PyObject * obj0 = 0 ;
5764 char *kwnames[] = {
5765 (char *) "pt", NULL
5766 };
5767
5768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5769 {
5770 arg1 = &temp1;
5771 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5772 }
5773 {
5774 if (!wxPyCheckForApp()) SWIG_fail;
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5777
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 {
5782 resultobj = wxPyMake_wxObject(result, 0);
5783 }
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj;
5792 wxPoint *arg1 = 0 ;
5793 wxWindow *result;
5794 wxPoint temp1 ;
5795 PyObject * obj0 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "pt", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5801 {
5802 arg1 = &temp1;
5803 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5804 }
5805 {
5806 if (!wxPyCheckForApp()) SWIG_fail;
5807 PyThreadState* __tstate = wxPyBeginAllowThreads();
5808 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5809
5810 wxPyEndAllowThreads(__tstate);
5811 if (PyErr_Occurred()) SWIG_fail;
5812 }
5813 {
5814 resultobj = wxPyMake_wxObject(result, 0);
5815 }
5816 return resultobj;
5817 fail:
5818 return NULL;
5819 }
5820
5821
5822 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5823 PyObject *resultobj;
5824 wxWindow *arg1 = (wxWindow *) 0 ;
5825 wxWindow *result;
5826 PyObject * obj0 = 0 ;
5827 char *kwnames[] = {
5828 (char *) "win", NULL
5829 };
5830
5831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5833 if (SWIG_arg_fail(1)) SWIG_fail;
5834 {
5835 if (!wxPyCheckForApp()) SWIG_fail;
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (wxWindow *)wxGetTopLevelParent(arg1);
5838
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 {
5843 resultobj = wxPyMake_wxObject(result, 0);
5844 }
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5852 PyObject *resultobj;
5853 wxKeyCode arg1 ;
5854 bool result;
5855 PyObject * obj0 = 0 ;
5856 char *kwnames[] = {
5857 (char *) "key", NULL
5858 };
5859
5860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5861 {
5862 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5863 if (SWIG_arg_fail(1)) SWIG_fail;
5864 }
5865 {
5866 if (!wxPyCheckForApp()) SWIG_fail;
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5869
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 {
5874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5875 }
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj;
5884 char *kwnames[] = {
5885 NULL
5886 };
5887
5888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5889 {
5890 if (!wxPyCheckForApp()) SWIG_fail;
5891 PyThreadState* __tstate = wxPyBeginAllowThreads();
5892 wxWakeUpMainThread();
5893
5894 wxPyEndAllowThreads(__tstate);
5895 if (PyErr_Occurred()) SWIG_fail;
5896 }
5897 Py_INCREF(Py_None); resultobj = Py_None;
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5905 PyObject *resultobj;
5906 char *kwnames[] = {
5907 NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5911 {
5912 if (!wxPyCheckForApp()) SWIG_fail;
5913 PyThreadState* __tstate = wxPyBeginAllowThreads();
5914 wxMutexGuiEnter();
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 Py_INCREF(Py_None); resultobj = Py_None;
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 char *kwnames[] = {
5929 NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5933 {
5934 if (!wxPyCheckForApp()) SWIG_fail;
5935 PyThreadState* __tstate = wxPyBeginAllowThreads();
5936 wxMutexGuiLeave();
5937
5938 wxPyEndAllowThreads(__tstate);
5939 if (PyErr_Occurred()) SWIG_fail;
5940 }
5941 Py_INCREF(Py_None); resultobj = Py_None;
5942 return resultobj;
5943 fail:
5944 return NULL;
5945 }
5946
5947
5948 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj;
5950 wxMutexGuiLocker *result;
5951 char *kwnames[] = {
5952 NULL
5953 };
5954
5955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5956 {
5957 if (!wxPyCheckForApp()) SWIG_fail;
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5960
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj;
5973 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5974 PyObject * obj0 = 0 ;
5975 char *kwnames[] = {
5976 (char *) "self", NULL
5977 };
5978
5979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5981 if (SWIG_arg_fail(1)) SWIG_fail;
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 delete arg1;
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 Py_INCREF(Py_None); resultobj = Py_None;
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5997 PyObject *obj;
5998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5999 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6000 Py_INCREF(obj);
6001 return Py_BuildValue((char *)"");
6002 }
6003 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj;
6005 bool result;
6006 char *kwnames[] = {
6007 NULL
6008 };
6009
6010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6011 {
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = (bool)wxThread_IsMain();
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 {
6019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6020 }
6021 return resultobj;
6022 fail:
6023 return NULL;
6024 }
6025
6026
6027 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6028 PyObject *resultobj;
6029 wxString *arg1 = 0 ;
6030 wxToolTip *result;
6031 bool temp1 = false ;
6032 PyObject * obj0 = 0 ;
6033 char *kwnames[] = {
6034 (char *) "tip", NULL
6035 };
6036
6037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6038 {
6039 arg1 = wxString_in_helper(obj0);
6040 if (arg1 == NULL) SWIG_fail;
6041 temp1 = true;
6042 }
6043 {
6044 if (!wxPyCheckForApp()) SWIG_fail;
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6047
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 resultobj = wxPyMake_wxObject(result, 1);
6053 }
6054 {
6055 if (temp1)
6056 delete arg1;
6057 }
6058 return resultobj;
6059 fail:
6060 {
6061 if (temp1)
6062 delete arg1;
6063 }
6064 return NULL;
6065 }
6066
6067
6068 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj;
6070 wxToolTip *arg1 = (wxToolTip *) 0 ;
6071 wxString *arg2 = 0 ;
6072 bool temp2 = false ;
6073 PyObject * obj0 = 0 ;
6074 PyObject * obj1 = 0 ;
6075 char *kwnames[] = {
6076 (char *) "self",(char *) "tip", NULL
6077 };
6078
6079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6081 if (SWIG_arg_fail(1)) SWIG_fail;
6082 {
6083 arg2 = wxString_in_helper(obj1);
6084 if (arg2 == NULL) SWIG_fail;
6085 temp2 = true;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 (arg1)->SetTip((wxString const &)*arg2);
6090
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 Py_INCREF(Py_None); resultobj = Py_None;
6095 {
6096 if (temp2)
6097 delete arg2;
6098 }
6099 return resultobj;
6100 fail:
6101 {
6102 if (temp2)
6103 delete arg2;
6104 }
6105 return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj;
6111 wxToolTip *arg1 = (wxToolTip *) 0 ;
6112 wxString result;
6113 PyObject * obj0 = 0 ;
6114 char *kwnames[] = {
6115 (char *) "self", NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6120 if (SWIG_arg_fail(1)) SWIG_fail;
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (arg1)->GetTip();
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 #if wxUSE_UNICODE
6130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6131 #else
6132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6133 #endif
6134 }
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj;
6143 wxToolTip *arg1 = (wxToolTip *) 0 ;
6144 wxWindow *result;
6145 PyObject * obj0 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "self", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6152 if (SWIG_arg_fail(1)) SWIG_fail;
6153 {
6154 PyThreadState* __tstate = wxPyBeginAllowThreads();
6155 result = (wxWindow *)(arg1)->GetWindow();
6156
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 {
6161 resultobj = wxPyMake_wxObject(result, 0);
6162 }
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 bool arg1 ;
6172 PyObject * obj0 = 0 ;
6173 char *kwnames[] = {
6174 (char *) "flag", NULL
6175 };
6176
6177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6178 {
6179 arg1 = (bool)(SWIG_As_bool(obj0));
6180 if (SWIG_arg_fail(1)) SWIG_fail;
6181 }
6182 {
6183 PyThreadState* __tstate = wxPyBeginAllowThreads();
6184 wxToolTip::Enable(arg1);
6185
6186 wxPyEndAllowThreads(__tstate);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 Py_INCREF(Py_None); resultobj = Py_None;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6197 PyObject *resultobj;
6198 long arg1 ;
6199 PyObject * obj0 = 0 ;
6200 char *kwnames[] = {
6201 (char *) "milliseconds", NULL
6202 };
6203
6204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6205 {
6206 arg1 = (long)(SWIG_As_long(obj0));
6207 if (SWIG_arg_fail(1)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 wxToolTip::SetDelay(arg1);
6212
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 Py_INCREF(Py_None); resultobj = Py_None;
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6224 PyObject *obj;
6225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6226 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6227 Py_INCREF(obj);
6228 return Py_BuildValue((char *)"");
6229 }
6230 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxWindow *arg1 = (wxWindow *) 0 ;
6233 wxSize *arg2 = 0 ;
6234 wxCaret *result;
6235 wxSize temp2 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 char *kwnames[] = {
6239 (char *) "window",(char *) "size", NULL
6240 };
6241
6242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6244 if (SWIG_arg_fail(1)) SWIG_fail;
6245 {
6246 arg2 = &temp2;
6247 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6248 }
6249 {
6250 if (!wxPyCheckForApp()) SWIG_fail;
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6253
6254 wxPyEndAllowThreads(__tstate);
6255 if (PyErr_Occurred()) SWIG_fail;
6256 }
6257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6258 return resultobj;
6259 fail:
6260 return NULL;
6261 }
6262
6263
6264 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6265 PyObject *resultobj;
6266 wxCaret *arg1 = (wxCaret *) 0 ;
6267 PyObject * obj0 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 PyThreadState* __tstate = wxPyBeginAllowThreads();
6277 delete arg1;
6278
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 Py_INCREF(Py_None); resultobj = Py_None;
6283 return resultobj;
6284 fail:
6285 return NULL;
6286 }
6287
6288
6289 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6290 PyObject *resultobj;
6291 wxCaret *arg1 = (wxCaret *) 0 ;
6292 bool result;
6293 PyObject * obj0 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 {
6302 PyThreadState* __tstate = wxPyBeginAllowThreads();
6303 result = (bool)(arg1)->IsOk();
6304
6305 wxPyEndAllowThreads(__tstate);
6306 if (PyErr_Occurred()) SWIG_fail;
6307 }
6308 {
6309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6310 }
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj;
6319 wxCaret *arg1 = (wxCaret *) 0 ;
6320 bool result;
6321 PyObject * obj0 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 result = (bool)(arg1)->IsVisible();
6332
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 {
6337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6338 }
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6346 PyObject *resultobj;
6347 wxCaret *arg1 = (wxCaret *) 0 ;
6348 wxPoint result;
6349 PyObject * obj0 = 0 ;
6350 char *kwnames[] = {
6351 (char *) "self", NULL
6352 };
6353
6354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (arg1)->GetPosition();
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 {
6365 wxPoint * resultptr;
6366 resultptr = new wxPoint((wxPoint &)(result));
6367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6368 }
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6376 PyObject *resultobj;
6377 wxCaret *arg1 = (wxCaret *) 0 ;
6378 int *arg2 = (int *) 0 ;
6379 int *arg3 = (int *) 0 ;
6380 int temp2 ;
6381 int res2 = 0 ;
6382 int temp3 ;
6383 int res3 = 0 ;
6384 PyObject * obj0 = 0 ;
6385 char *kwnames[] = {
6386 (char *) "self", NULL
6387 };
6388
6389 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6390 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6393 if (SWIG_arg_fail(1)) SWIG_fail;
6394 {
6395 PyThreadState* __tstate = wxPyBeginAllowThreads();
6396 (arg1)->GetPosition(arg2,arg3);
6397
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 Py_INCREF(Py_None); resultobj = Py_None;
6402 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6403 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6404 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6405 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6413 PyObject *resultobj;
6414 wxCaret *arg1 = (wxCaret *) 0 ;
6415 wxSize result;
6416 PyObject * obj0 = 0 ;
6417 char *kwnames[] = {
6418 (char *) "self", NULL
6419 };
6420
6421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6423 if (SWIG_arg_fail(1)) SWIG_fail;
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (arg1)->GetSize();
6427
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 {
6432 wxSize * resultptr;
6433 resultptr = new wxSize((wxSize &)(result));
6434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6435 }
6436 return resultobj;
6437 fail:
6438 return NULL;
6439 }
6440
6441
6442 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6443 PyObject *resultobj;
6444 wxCaret *arg1 = (wxCaret *) 0 ;
6445 int *arg2 = (int *) 0 ;
6446 int *arg3 = (int *) 0 ;
6447 int temp2 ;
6448 int res2 = 0 ;
6449 int temp3 ;
6450 int res3 = 0 ;
6451 PyObject * obj0 = 0 ;
6452 char *kwnames[] = {
6453 (char *) "self", NULL
6454 };
6455
6456 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6457 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6460 if (SWIG_arg_fail(1)) SWIG_fail;
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 (arg1)->GetSize(arg2,arg3);
6464
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 Py_INCREF(Py_None); resultobj = Py_None;
6469 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6470 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6471 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6472 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6473 return resultobj;
6474 fail:
6475 return NULL;
6476 }
6477
6478
6479 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6480 PyObject *resultobj;
6481 wxCaret *arg1 = (wxCaret *) 0 ;
6482 wxWindow *result;
6483 PyObject * obj0 = 0 ;
6484 char *kwnames[] = {
6485 (char *) "self", NULL
6486 };
6487
6488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6490 if (SWIG_arg_fail(1)) SWIG_fail;
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (wxWindow *)(arg1)->GetWindow();
6494
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 {
6499 resultobj = wxPyMake_wxObject(result, 0);
6500 }
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxCaret *arg1 = (wxCaret *) 0 ;
6510 int arg2 ;
6511 int arg3 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 PyObject * obj2 = 0 ;
6515 char *kwnames[] = {
6516 (char *) "self",(char *) "x",(char *) "y", NULL
6517 };
6518
6519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6521 if (SWIG_arg_fail(1)) SWIG_fail;
6522 {
6523 arg2 = (int)(SWIG_As_int(obj1));
6524 if (SWIG_arg_fail(2)) SWIG_fail;
6525 }
6526 {
6527 arg3 = (int)(SWIG_As_int(obj2));
6528 if (SWIG_arg_fail(3)) SWIG_fail;
6529 }
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 (arg1)->Move(arg2,arg3);
6533
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 Py_INCREF(Py_None); resultobj = Py_None;
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxCaret *arg1 = (wxCaret *) 0 ;
6547 wxPoint *arg2 = 0 ;
6548 wxPoint temp2 ;
6549 PyObject * obj0 = 0 ;
6550 PyObject * obj1 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self",(char *) "pt", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 {
6559 arg2 = &temp2;
6560 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6561 }
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 (arg1)->Move((wxPoint const &)*arg2);
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 Py_INCREF(Py_None); resultobj = Py_None;
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6577 PyObject *resultobj;
6578 wxCaret *arg1 = (wxCaret *) 0 ;
6579 int arg2 ;
6580 int arg3 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 PyObject * obj2 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self",(char *) "width",(char *) "height", NULL
6586 };
6587
6588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6590 if (SWIG_arg_fail(1)) SWIG_fail;
6591 {
6592 arg2 = (int)(SWIG_As_int(obj1));
6593 if (SWIG_arg_fail(2)) SWIG_fail;
6594 }
6595 {
6596 arg3 = (int)(SWIG_As_int(obj2));
6597 if (SWIG_arg_fail(3)) SWIG_fail;
6598 }
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 (arg1)->SetSize(arg2,arg3);
6602
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 Py_INCREF(Py_None); resultobj = Py_None;
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6614 PyObject *resultobj;
6615 wxCaret *arg1 = (wxCaret *) 0 ;
6616 wxSize *arg2 = 0 ;
6617 wxSize temp2 ;
6618 PyObject * obj0 = 0 ;
6619 PyObject * obj1 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "self",(char *) "size", NULL
6622 };
6623
6624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6626 if (SWIG_arg_fail(1)) SWIG_fail;
6627 {
6628 arg2 = &temp2;
6629 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6630 }
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 (arg1)->SetSize((wxSize const &)*arg2);
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 Py_INCREF(Py_None); resultobj = Py_None;
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj;
6647 wxCaret *arg1 = (wxCaret *) 0 ;
6648 int arg2 = (int) true ;
6649 PyObject * obj0 = 0 ;
6650 PyObject * obj1 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self",(char *) "show", NULL
6653 };
6654
6655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 if (obj1) {
6659 {
6660 arg2 = (int)(SWIG_As_int(obj1));
6661 if (SWIG_arg_fail(2)) SWIG_fail;
6662 }
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->Show(arg2);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 Py_INCREF(Py_None); resultobj = Py_None;
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxCaret *arg1 = (wxCaret *) 0 ;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->Hide();
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 * Caret_swigregister(PyObject *, PyObject *args) {
6704 PyObject *obj;
6705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6706 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6707 Py_INCREF(obj);
6708 return Py_BuildValue((char *)"");
6709 }
6710 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6711 PyObject *resultobj;
6712 int result;
6713 char *kwnames[] = {
6714 NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6718 {
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 result = (int)wxCaret_GetBlinkTime();
6721
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 {
6726 resultobj = SWIG_From_int((int)(result));
6727 }
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 int arg1 ;
6737 PyObject * obj0 = 0 ;
6738 char *kwnames[] = {
6739 (char *) "milliseconds", NULL
6740 };
6741
6742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6743 {
6744 arg1 = (int)(SWIG_As_int(obj0));
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 }
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 wxCaret_SetBlinkTime(arg1);
6750
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 Py_INCREF(Py_None); resultobj = Py_None;
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6762 PyObject *resultobj;
6763 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6764 wxBusyCursor *result;
6765 PyObject * obj0 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "cursor", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6771 if (obj0) {
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 }
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6793 PyObject * obj0 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 delete arg1;
6804
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 Py_INCREF(Py_None); resultobj = Py_None;
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6816 PyObject *obj;
6817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6818 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6819 Py_INCREF(obj);
6820 return Py_BuildValue((char *)"");
6821 }
6822 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj;
6824 wxWindow *arg1 = (wxWindow *) NULL ;
6825 wxWindowDisabler *result;
6826 PyObject * obj0 = 0 ;
6827 char *kwnames[] = {
6828 (char *) "winToSkip", NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6832 if (obj0) {
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 }
6836 {
6837 if (!wxPyCheckForApp()) SWIG_fail;
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6840
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj;
6853 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6854 PyObject * obj0 = 0 ;
6855 char *kwnames[] = {
6856 (char *) "self", NULL
6857 };
6858
6859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6861 if (SWIG_arg_fail(1)) SWIG_fail;
6862 {
6863 PyThreadState* __tstate = wxPyBeginAllowThreads();
6864 delete arg1;
6865
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 Py_INCREF(Py_None); resultobj = Py_None;
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6877 PyObject *obj;
6878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6879 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6880 Py_INCREF(obj);
6881 return Py_BuildValue((char *)"");
6882 }
6883 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj;
6885 wxString *arg1 = 0 ;
6886 wxBusyInfo *result;
6887 bool temp1 = false ;
6888 PyObject * obj0 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "message", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6894 {
6895 arg1 = wxString_in_helper(obj0);
6896 if (arg1 == NULL) SWIG_fail;
6897 temp1 = true;
6898 }
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6908 {
6909 if (temp1)
6910 delete arg1;
6911 }
6912 return resultobj;
6913 fail:
6914 {
6915 if (temp1)
6916 delete arg1;
6917 }
6918 return NULL;
6919 }
6920
6921
6922 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6923 PyObject *resultobj;
6924 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6925 PyObject * obj0 = 0 ;
6926 char *kwnames[] = {
6927 (char *) "self", NULL
6928 };
6929
6930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6932 if (SWIG_arg_fail(1)) SWIG_fail;
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 delete arg1;
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6948 PyObject *obj;
6949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6950 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6951 Py_INCREF(obj);
6952 return Py_BuildValue((char *)"");
6953 }
6954 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj;
6956 wxStopWatch *result;
6957 char *kwnames[] = {
6958 NULL
6959 };
6960
6961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 result = (wxStopWatch *)new wxStopWatch();
6965
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj;
6978 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6979 long arg2 = (long) 0 ;
6980 PyObject * obj0 = 0 ;
6981 PyObject * obj1 = 0 ;
6982 char *kwnames[] = {
6983 (char *) "self",(char *) "t0", NULL
6984 };
6985
6986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6988 if (SWIG_arg_fail(1)) SWIG_fail;
6989 if (obj1) {
6990 {
6991 arg2 = (long)(SWIG_As_long(obj1));
6992 if (SWIG_arg_fail(2)) SWIG_fail;
6993 }
6994 }
6995 {
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 (arg1)->Start(arg2);
6998
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 Py_INCREF(Py_None); resultobj = Py_None;
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj;
7011 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7012 PyObject * obj0 = 0 ;
7013 char *kwnames[] = {
7014 (char *) "self", NULL
7015 };
7016
7017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7019 if (SWIG_arg_fail(1)) SWIG_fail;
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 (arg1)->Pause();
7023
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 Py_INCREF(Py_None); resultobj = Py_None;
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj;
7036 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7037 PyObject * obj0 = 0 ;
7038 char *kwnames[] = {
7039 (char *) "self", NULL
7040 };
7041
7042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(1)) SWIG_fail;
7045 {
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 (arg1)->Resume();
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 Py_INCREF(Py_None); resultobj = Py_None;
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7060 PyObject *resultobj;
7061 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7062 long result;
7063 PyObject * obj0 = 0 ;
7064 char *kwnames[] = {
7065 (char *) "self", NULL
7066 };
7067
7068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7070 if (SWIG_arg_fail(1)) SWIG_fail;
7071 {
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 result = (long)((wxStopWatch const *)arg1)->Time();
7074
7075 wxPyEndAllowThreads(__tstate);
7076 if (PyErr_Occurred()) SWIG_fail;
7077 }
7078 {
7079 resultobj = SWIG_From_long((long)(result));
7080 }
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7088 PyObject *obj;
7089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7090 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7091 Py_INCREF(obj);
7092 return Py_BuildValue((char *)"");
7093 }
7094 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7095 PyObject *resultobj;
7096 int arg1 = (int) 9 ;
7097 int arg2 = (int) wxID_FILE1 ;
7098 wxFileHistory *result;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "maxFiles",(char *) "idBase", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7106 if (obj0) {
7107 {
7108 arg1 = (int)(SWIG_As_int(obj0));
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 }
7111 }
7112 if (obj1) {
7113 {
7114 arg2 = (int)(SWIG_As_int(obj1));
7115 if (SWIG_arg_fail(2)) SWIG_fail;
7116 }
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7133 PyObject *resultobj;
7134 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7135 PyObject * obj0 = 0 ;
7136 char *kwnames[] = {
7137 (char *) "self", NULL
7138 };
7139
7140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7142 if (SWIG_arg_fail(1)) SWIG_fail;
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 delete arg1;
7146
7147 wxPyEndAllowThreads(__tstate);
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 Py_INCREF(Py_None); resultobj = Py_None;
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7160 wxString *arg2 = 0 ;
7161 bool temp2 = false ;
7162 PyObject * obj0 = 0 ;
7163 PyObject * obj1 = 0 ;
7164 char *kwnames[] = {
7165 (char *) "self",(char *) "file", NULL
7166 };
7167
7168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7170 if (SWIG_arg_fail(1)) SWIG_fail;
7171 {
7172 arg2 = wxString_in_helper(obj1);
7173 if (arg2 == NULL) SWIG_fail;
7174 temp2 = true;
7175 }
7176 {
7177 PyThreadState* __tstate = wxPyBeginAllowThreads();
7178 (arg1)->AddFileToHistory((wxString const &)*arg2);
7179
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 Py_INCREF(Py_None); resultobj = Py_None;
7184 {
7185 if (temp2)
7186 delete arg2;
7187 }
7188 return resultobj;
7189 fail:
7190 {
7191 if (temp2)
7192 delete arg2;
7193 }
7194 return NULL;
7195 }
7196
7197
7198 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj;
7200 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7201 int arg2 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 char *kwnames[] = {
7205 (char *) "self",(char *) "i", NULL
7206 };
7207
7208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 {
7212 arg2 = (int)(SWIG_As_int(obj1));
7213 if (SWIG_arg_fail(2)) SWIG_fail;
7214 }
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 (arg1)->RemoveFileFromHistory(arg2);
7218
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 Py_INCREF(Py_None); resultobj = Py_None;
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7230 PyObject *resultobj;
7231 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7232 int result;
7233 PyObject * obj0 = 0 ;
7234 char *kwnames[] = {
7235 (char *) "self", NULL
7236 };
7237
7238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7240 if (SWIG_arg_fail(1)) SWIG_fail;
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7244
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 {
7249 resultobj = SWIG_From_int((int)(result));
7250 }
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj;
7259 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7260 wxMenu *arg2 = (wxMenu *) 0 ;
7261 PyObject * obj0 = 0 ;
7262 PyObject * obj1 = 0 ;
7263 char *kwnames[] = {
7264 (char *) "self",(char *) "menu", NULL
7265 };
7266
7267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7271 if (SWIG_arg_fail(2)) SWIG_fail;
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 (arg1)->UseMenu(arg2);
7275
7276 wxPyEndAllowThreads(__tstate);
7277 if (PyErr_Occurred()) SWIG_fail;
7278 }
7279 Py_INCREF(Py_None); resultobj = Py_None;
7280 return resultobj;
7281 fail:
7282 return NULL;
7283 }
7284
7285
7286 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7287 PyObject *resultobj;
7288 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7289 wxMenu *arg2 = (wxMenu *) 0 ;
7290 PyObject * obj0 = 0 ;
7291 PyObject * obj1 = 0 ;
7292 char *kwnames[] = {
7293 (char *) "self",(char *) "menu", NULL
7294 };
7295
7296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7298 if (SWIG_arg_fail(1)) SWIG_fail;
7299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7300 if (SWIG_arg_fail(2)) SWIG_fail;
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 (arg1)->RemoveMenu(arg2);
7304
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 Py_INCREF(Py_None); resultobj = Py_None;
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj;
7317 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7318 wxConfigBase *arg2 = 0 ;
7319 PyObject * obj0 = 0 ;
7320 PyObject * obj1 = 0 ;
7321 char *kwnames[] = {
7322 (char *) "self",(char *) "config", NULL
7323 };
7324
7325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7327 if (SWIG_arg_fail(1)) SWIG_fail;
7328 {
7329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(2)) SWIG_fail;
7331 if (arg2 == NULL) {
7332 SWIG_null_ref("wxConfigBase");
7333 }
7334 if (SWIG_arg_fail(2)) SWIG_fail;
7335 }
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 (arg1)->Load(*arg2);
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 Py_INCREF(Py_None); resultobj = Py_None;
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj;
7352 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7353 wxConfigBase *arg2 = 0 ;
7354 PyObject * obj0 = 0 ;
7355 PyObject * obj1 = 0 ;
7356 char *kwnames[] = {
7357 (char *) "self",(char *) "config", NULL
7358 };
7359
7360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7362 if (SWIG_arg_fail(1)) SWIG_fail;
7363 {
7364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7365 if (SWIG_arg_fail(2)) SWIG_fail;
7366 if (arg2 == NULL) {
7367 SWIG_null_ref("wxConfigBase");
7368 }
7369 if (SWIG_arg_fail(2)) SWIG_fail;
7370 }
7371 {
7372 PyThreadState* __tstate = wxPyBeginAllowThreads();
7373 (arg1)->Save(*arg2);
7374
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 Py_INCREF(Py_None); resultobj = Py_None;
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj;
7387 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7388 PyObject * obj0 = 0 ;
7389 char *kwnames[] = {
7390 (char *) "self", NULL
7391 };
7392
7393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7395 if (SWIG_arg_fail(1)) SWIG_fail;
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 (arg1)->AddFilesToMenu();
7399
7400 wxPyEndAllowThreads(__tstate);
7401 if (PyErr_Occurred()) SWIG_fail;
7402 }
7403 Py_INCREF(Py_None); resultobj = Py_None;
7404 return resultobj;
7405 fail:
7406 return NULL;
7407 }
7408
7409
7410 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7411 PyObject *resultobj;
7412 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7413 wxMenu *arg2 = (wxMenu *) 0 ;
7414 PyObject * obj0 = 0 ;
7415 PyObject * obj1 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self",(char *) "menu", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7424 if (SWIG_arg_fail(2)) SWIG_fail;
7425 {
7426 PyThreadState* __tstate = wxPyBeginAllowThreads();
7427 (arg1)->AddFilesToMenu(arg2);
7428
7429 wxPyEndAllowThreads(__tstate);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 Py_INCREF(Py_None); resultobj = Py_None;
7433 return resultobj;
7434 fail:
7435 return NULL;
7436 }
7437
7438
7439 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7440 PyObject *resultobj;
7441 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7442 int arg2 ;
7443 wxString result;
7444 PyObject * obj0 = 0 ;
7445 PyObject * obj1 = 0 ;
7446 char *kwnames[] = {
7447 (char *) "self",(char *) "i", NULL
7448 };
7449
7450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7452 if (SWIG_arg_fail(1)) SWIG_fail;
7453 {
7454 arg2 = (int)(SWIG_As_int(obj1));
7455 if (SWIG_arg_fail(2)) SWIG_fail;
7456 }
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 #if wxUSE_UNICODE
7466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7467 #else
7468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7469 #endif
7470 }
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7480 int result;
7481 PyObject * obj0 = 0 ;
7482 char *kwnames[] = {
7483 (char *) "self", NULL
7484 };
7485
7486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7488 if (SWIG_arg_fail(1)) SWIG_fail;
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (int)((wxFileHistory const *)arg1)->GetCount();
7492
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497 resultobj = SWIG_From_int((int)(result));
7498 }
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7506 PyObject *obj;
7507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7508 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7509 Py_INCREF(obj);
7510 return Py_BuildValue((char *)"");
7511 }
7512 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxString *arg1 = 0 ;
7515 wxString const &arg2_defvalue = wxPyEmptyString ;
7516 wxString *arg2 = (wxString *) &arg2_defvalue ;
7517 wxSingleInstanceChecker *result;
7518 bool temp1 = false ;
7519 bool temp2 = false ;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char *kwnames[] = {
7523 (char *) "name",(char *) "path", NULL
7524 };
7525
7526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7527 {
7528 arg1 = wxString_in_helper(obj0);
7529 if (arg1 == NULL) SWIG_fail;
7530 temp1 = true;
7531 }
7532 if (obj1) {
7533 {
7534 arg2 = wxString_in_helper(obj1);
7535 if (arg2 == NULL) SWIG_fail;
7536 temp2 = true;
7537 }
7538 }
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7547 {
7548 if (temp1)
7549 delete arg1;
7550 }
7551 {
7552 if (temp2)
7553 delete arg2;
7554 }
7555 return resultobj;
7556 fail:
7557 {
7558 if (temp1)
7559 delete arg1;
7560 }
7561 {
7562 if (temp2)
7563 delete arg2;
7564 }
7565 return NULL;
7566 }
7567
7568
7569 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7570 PyObject *resultobj;
7571 wxSingleInstanceChecker *result;
7572 char *kwnames[] = {
7573 NULL
7574 };
7575
7576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7580
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj;
7593 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7594 PyObject * obj0 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 delete arg1;
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 Py_INCREF(Py_None); resultobj = Py_None;
7610 return resultobj;
7611 fail:
7612 return NULL;
7613 }
7614
7615
7616 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7617 PyObject *resultobj;
7618 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7619 wxString *arg2 = 0 ;
7620 wxString const &arg3_defvalue = wxPyEmptyString ;
7621 wxString *arg3 = (wxString *) &arg3_defvalue ;
7622 bool result;
7623 bool temp2 = false ;
7624 bool temp3 = false ;
7625 PyObject * obj0 = 0 ;
7626 PyObject * obj1 = 0 ;
7627 PyObject * obj2 = 0 ;
7628 char *kwnames[] = {
7629 (char *) "self",(char *) "name",(char *) "path", NULL
7630 };
7631
7632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7634 if (SWIG_arg_fail(1)) SWIG_fail;
7635 {
7636 arg2 = wxString_in_helper(obj1);
7637 if (arg2 == NULL) SWIG_fail;
7638 temp2 = true;
7639 }
7640 if (obj2) {
7641 {
7642 arg3 = wxString_in_helper(obj2);
7643 if (arg3 == NULL) SWIG_fail;
7644 temp3 = true;
7645 }
7646 }
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7650
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 {
7655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7656 }
7657 {
7658 if (temp2)
7659 delete arg2;
7660 }
7661 {
7662 if (temp3)
7663 delete arg3;
7664 }
7665 return resultobj;
7666 fail:
7667 {
7668 if (temp2)
7669 delete arg2;
7670 }
7671 {
7672 if (temp3)
7673 delete arg3;
7674 }
7675 return NULL;
7676 }
7677
7678
7679 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj;
7681 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7682 bool result;
7683 PyObject * obj0 = 0 ;
7684 char *kwnames[] = {
7685 (char *) "self", NULL
7686 };
7687
7688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7690 if (SWIG_arg_fail(1)) SWIG_fail;
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7694
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 {
7699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7700 }
7701 return resultobj;
7702 fail:
7703 return NULL;
7704 }
7705
7706
7707 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7708 PyObject *obj;
7709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7710 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7711 Py_INCREF(obj);
7712 return Py_BuildValue((char *)"");
7713 }
7714 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7715 PyObject *resultobj;
7716 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7717 PyObject * obj0 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7724 if (SWIG_arg_fail(1)) SWIG_fail;
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 delete arg1;
7728
7729 wxPyEndAllowThreads(__tstate);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 Py_INCREF(Py_None); resultobj = Py_None;
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7740 PyObject *resultobj;
7741 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7742 wxString result;
7743 PyObject * obj0 = 0 ;
7744 char *kwnames[] = {
7745 (char *) "self", NULL
7746 };
7747
7748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7750 if (SWIG_arg_fail(1)) SWIG_fail;
7751 {
7752 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753 result = (arg1)->GetTip();
7754
7755 wxPyEndAllowThreads(__tstate);
7756 if (PyErr_Occurred()) SWIG_fail;
7757 }
7758 {
7759 #if wxUSE_UNICODE
7760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7761 #else
7762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7763 #endif
7764 }
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7772 PyObject *resultobj;
7773 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7774 size_t result;
7775 PyObject * obj0 = 0 ;
7776 char *kwnames[] = {
7777 (char *) "self", NULL
7778 };
7779
7780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7782 if (SWIG_arg_fail(1)) SWIG_fail;
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 result = (size_t)(arg1)->GetCurrentTip();
7786
7787 wxPyEndAllowThreads(__tstate);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 {
7791 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7792 }
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj;
7801 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7802 wxString *arg2 = 0 ;
7803 wxString result;
7804 bool temp2 = false ;
7805 PyObject * obj0 = 0 ;
7806 PyObject * obj1 = 0 ;
7807 char *kwnames[] = {
7808 (char *) "self",(char *) "tip", NULL
7809 };
7810
7811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7813 if (SWIG_arg_fail(1)) SWIG_fail;
7814 {
7815 arg2 = wxString_in_helper(obj1);
7816 if (arg2 == NULL) SWIG_fail;
7817 temp2 = true;
7818 }
7819 {
7820 PyThreadState* __tstate = wxPyBeginAllowThreads();
7821 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7822
7823 wxPyEndAllowThreads(__tstate);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 {
7827 #if wxUSE_UNICODE
7828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7829 #else
7830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7831 #endif
7832 }
7833 {
7834 if (temp2)
7835 delete arg2;
7836 }
7837 return resultobj;
7838 fail:
7839 {
7840 if (temp2)
7841 delete arg2;
7842 }
7843 return NULL;
7844 }
7845
7846
7847 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7848 PyObject *obj;
7849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7850 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7851 Py_INCREF(obj);
7852 return Py_BuildValue((char *)"");
7853 }
7854 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7855 PyObject *resultobj;
7856 size_t arg1 ;
7857 wxPyTipProvider *result;
7858 PyObject * obj0 = 0 ;
7859 char *kwnames[] = {
7860 (char *) "currentTip", NULL
7861 };
7862
7863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7864 {
7865 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7866 if (SWIG_arg_fail(1)) SWIG_fail;
7867 }
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7871
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7885 PyObject *arg2 = (PyObject *) 0 ;
7886 PyObject *arg3 = (PyObject *) 0 ;
7887 PyObject * obj0 = 0 ;
7888 PyObject * obj1 = 0 ;
7889 PyObject * obj2 = 0 ;
7890 char *kwnames[] = {
7891 (char *) "self",(char *) "self",(char *) "_class", NULL
7892 };
7893
7894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7896 if (SWIG_arg_fail(1)) SWIG_fail;
7897 arg2 = obj1;
7898 arg3 = obj2;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 (arg1)->_setCallbackInfo(arg2,arg3);
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 Py_INCREF(Py_None); resultobj = Py_None;
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7914 PyObject *obj;
7915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7916 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7917 Py_INCREF(obj);
7918 return Py_BuildValue((char *)"");
7919 }
7920 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxWindow *arg1 = (wxWindow *) 0 ;
7923 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7924 bool arg3 = (bool) true ;
7925 bool result;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 PyObject * obj2 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7937 if (SWIG_arg_fail(2)) SWIG_fail;
7938 if (obj2) {
7939 {
7940 arg3 = (bool)(SWIG_As_bool(obj2));
7941 if (SWIG_arg_fail(3)) SWIG_fail;
7942 }
7943 }
7944 {
7945 if (!wxPyCheckForApp()) SWIG_fail;
7946 PyThreadState* __tstate = wxPyBeginAllowThreads();
7947 result = (bool)wxShowTip(arg1,arg2,arg3);
7948
7949 wxPyEndAllowThreads(__tstate);
7950 if (PyErr_Occurred()) SWIG_fail;
7951 }
7952 {
7953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7954 }
7955 return resultobj;
7956 fail:
7957 return NULL;
7958 }
7959
7960
7961 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7962 PyObject *resultobj;
7963 wxString *arg1 = 0 ;
7964 size_t arg2 ;
7965 wxTipProvider *result;
7966 bool temp1 = false ;
7967 PyObject * obj0 = 0 ;
7968 PyObject * obj1 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "filename",(char *) "currentTip", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7974 {
7975 arg1 = wxString_in_helper(obj0);
7976 if (arg1 == NULL) SWIG_fail;
7977 temp1 = true;
7978 }
7979 {
7980 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7981 if (SWIG_arg_fail(2)) SWIG_fail;
7982 }
7983 {
7984 if (!wxPyCheckForApp()) SWIG_fail;
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7987
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7992 {
7993 if (temp1)
7994 delete arg1;
7995 }
7996 return resultobj;
7997 fail:
7998 {
7999 if (temp1)
8000 delete arg1;
8001 }
8002 return NULL;
8003 }
8004
8005
8006 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8007 PyObject *resultobj;
8008 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8009 int arg2 = (int) -1 ;
8010 wxPyTimer *result;
8011 PyObject * obj0 = 0 ;
8012 PyObject * obj1 = 0 ;
8013 char *kwnames[] = {
8014 (char *) "owner",(char *) "id", NULL
8015 };
8016
8017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8018 if (obj0) {
8019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8020 if (SWIG_arg_fail(1)) SWIG_fail;
8021 }
8022 if (obj1) {
8023 {
8024 arg2 = (int)(SWIG_As_int(obj1));
8025 if (SWIG_arg_fail(2)) SWIG_fail;
8026 }
8027 }
8028 {
8029 if (!wxPyCheckForApp()) SWIG_fail;
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8032
8033 wxPyEndAllowThreads(__tstate);
8034 if (PyErr_Occurred()) SWIG_fail;
8035 }
8036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8037 return resultobj;
8038 fail:
8039 return NULL;
8040 }
8041
8042
8043 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8044 PyObject *resultobj;
8045 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8046 PyObject * obj0 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 delete arg1;
8057
8058 wxPyEndAllowThreads(__tstate);
8059 if (PyErr_Occurred()) SWIG_fail;
8060 }
8061 Py_INCREF(Py_None); resultobj = Py_None;
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8069 PyObject *resultobj;
8070 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8071 PyObject *arg2 = (PyObject *) 0 ;
8072 PyObject *arg3 = (PyObject *) 0 ;
8073 int arg4 = (int) 1 ;
8074 PyObject * obj0 = 0 ;
8075 PyObject * obj1 = 0 ;
8076 PyObject * obj2 = 0 ;
8077 PyObject * obj3 = 0 ;
8078 char *kwnames[] = {
8079 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8080 };
8081
8082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8084 if (SWIG_arg_fail(1)) SWIG_fail;
8085 arg2 = obj1;
8086 arg3 = obj2;
8087 if (obj3) {
8088 {
8089 arg4 = (int)(SWIG_As_int(obj3));
8090 if (SWIG_arg_fail(4)) SWIG_fail;
8091 }
8092 }
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8096
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 Py_INCREF(Py_None); resultobj = Py_None;
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8108 PyObject *resultobj;
8109 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8110 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8111 int arg3 = (int) -1 ;
8112 PyObject * obj0 = 0 ;
8113 PyObject * obj1 = 0 ;
8114 PyObject * obj2 = 0 ;
8115 char *kwnames[] = {
8116 (char *) "self",(char *) "owner",(char *) "id", NULL
8117 };
8118
8119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8121 if (SWIG_arg_fail(1)) SWIG_fail;
8122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8123 if (SWIG_arg_fail(2)) SWIG_fail;
8124 if (obj2) {
8125 {
8126 arg3 = (int)(SWIG_As_int(obj2));
8127 if (SWIG_arg_fail(3)) SWIG_fail;
8128 }
8129 }
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 (arg1)->SetOwner(arg2,arg3);
8133
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 Py_INCREF(Py_None); resultobj = Py_None;
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj;
8146 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8147 wxEvtHandler *result;
8148 PyObject * obj0 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 result = (wxEvtHandler *)(arg1)->GetOwner();
8159
8160 wxPyEndAllowThreads(__tstate);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 {
8164 resultobj = wxPyMake_wxObject(result, 0);
8165 }
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8175 int arg2 = (int) -1 ;
8176 bool arg3 = (bool) false ;
8177 bool result;
8178 PyObject * obj0 = 0 ;
8179 PyObject * obj1 = 0 ;
8180 PyObject * obj2 = 0 ;
8181 char *kwnames[] = {
8182 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8183 };
8184
8185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8187 if (SWIG_arg_fail(1)) SWIG_fail;
8188 if (obj1) {
8189 {
8190 arg2 = (int)(SWIG_As_int(obj1));
8191 if (SWIG_arg_fail(2)) SWIG_fail;
8192 }
8193 }
8194 if (obj2) {
8195 {
8196 arg3 = (bool)(SWIG_As_bool(obj2));
8197 if (SWIG_arg_fail(3)) SWIG_fail;
8198 }
8199 }
8200 {
8201 PyThreadState* __tstate = wxPyBeginAllowThreads();
8202 result = (bool)(arg1)->Start(arg2,arg3);
8203
8204 wxPyEndAllowThreads(__tstate);
8205 if (PyErr_Occurred()) SWIG_fail;
8206 }
8207 {
8208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8209 }
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8217 PyObject *resultobj;
8218 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8219 PyObject * obj0 = 0 ;
8220 char *kwnames[] = {
8221 (char *) "self", NULL
8222 };
8223
8224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8226 if (SWIG_arg_fail(1)) SWIG_fail;
8227 {
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 (arg1)->Stop();
8230
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 Py_INCREF(Py_None); resultobj = Py_None;
8235 return resultobj;
8236 fail:
8237 return NULL;
8238 }
8239
8240
8241 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj;
8243 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8244 bool result;
8245 PyObject * obj0 = 0 ;
8246 char *kwnames[] = {
8247 (char *) "self", NULL
8248 };
8249
8250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8252 if (SWIG_arg_fail(1)) SWIG_fail;
8253 {
8254 PyThreadState* __tstate = wxPyBeginAllowThreads();
8255 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8256
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 {
8261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8262 }
8263 return resultobj;
8264 fail:
8265 return NULL;
8266 }
8267
8268
8269 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj;
8271 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8272 int result;
8273 PyObject * obj0 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 resultobj = SWIG_From_int((int)(result));
8290 }
8291 return resultobj;
8292 fail:
8293 return NULL;
8294 }
8295
8296
8297 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj;
8299 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8300 bool result;
8301 PyObject * obj0 = 0 ;
8302 char *kwnames[] = {
8303 (char *) "self", NULL
8304 };
8305
8306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8308 if (SWIG_arg_fail(1)) SWIG_fail;
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8312
8313 wxPyEndAllowThreads(__tstate);
8314 if (PyErr_Occurred()) SWIG_fail;
8315 }
8316 {
8317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8318 }
8319 return resultobj;
8320 fail:
8321 return NULL;
8322 }
8323
8324
8325 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8326 PyObject *resultobj;
8327 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8328 int result;
8329 PyObject * obj0 = 0 ;
8330 char *kwnames[] = {
8331 (char *) "self", NULL
8332 };
8333
8334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8336 if (SWIG_arg_fail(1)) SWIG_fail;
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (int)((wxPyTimer const *)arg1)->GetId();
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = SWIG_From_int((int)(result));
8346 }
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8354 PyObject *obj;
8355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8356 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8357 Py_INCREF(obj);
8358 return Py_BuildValue((char *)"");
8359 }
8360 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 int arg1 = (int) 0 ;
8363 int arg2 = (int) 0 ;
8364 wxTimerEvent *result;
8365 PyObject * obj0 = 0 ;
8366 PyObject * obj1 = 0 ;
8367 char *kwnames[] = {
8368 (char *) "timerid",(char *) "interval", NULL
8369 };
8370
8371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8372 if (obj0) {
8373 {
8374 arg1 = (int)(SWIG_As_int(obj0));
8375 if (SWIG_arg_fail(1)) SWIG_fail;
8376 }
8377 }
8378 if (obj1) {
8379 {
8380 arg2 = (int)(SWIG_As_int(obj1));
8381 if (SWIG_arg_fail(2)) SWIG_fail;
8382 }
8383 }
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8387
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj;
8400 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8401 int result;
8402 PyObject * obj0 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 {
8418 resultobj = SWIG_From_int((int)(result));
8419 }
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8427 PyObject *obj;
8428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8429 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8430 Py_INCREF(obj);
8431 return Py_BuildValue((char *)"");
8432 }
8433 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8434 PyObject *resultobj;
8435 wxTimer *arg1 = 0 ;
8436 wxTimerRunner *result;
8437 PyObject * obj0 = 0 ;
8438
8439 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8440 {
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 if (arg1 == NULL) {
8444 SWIG_null_ref("wxTimer");
8445 }
8446 if (SWIG_arg_fail(1)) SWIG_fail;
8447 }
8448 {
8449 if (!wxPyCheckForApp()) SWIG_fail;
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8464 PyObject *resultobj;
8465 wxTimer *arg1 = 0 ;
8466 int arg2 ;
8467 bool arg3 = (bool) false ;
8468 wxTimerRunner *result;
8469 PyObject * obj0 = 0 ;
8470 PyObject * obj1 = 0 ;
8471 PyObject * obj2 = 0 ;
8472
8473 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8474 {
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 if (arg1 == NULL) {
8478 SWIG_null_ref("wxTimer");
8479 }
8480 if (SWIG_arg_fail(1)) SWIG_fail;
8481 }
8482 {
8483 arg2 = (int)(SWIG_As_int(obj1));
8484 if (SWIG_arg_fail(2)) SWIG_fail;
8485 }
8486 if (obj2) {
8487 {
8488 arg3 = (bool)(SWIG_As_bool(obj2));
8489 if (SWIG_arg_fail(3)) SWIG_fail;
8490 }
8491 }
8492 {
8493 if (!wxPyCheckForApp()) SWIG_fail;
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8496
8497 wxPyEndAllowThreads(__tstate);
8498 if (PyErr_Occurred()) SWIG_fail;
8499 }
8500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8508 int argc;
8509 PyObject *argv[4];
8510 int ii;
8511
8512 argc = PyObject_Length(args);
8513 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8514 argv[ii] = PyTuple_GetItem(args,ii);
8515 }
8516 if (argc == 1) {
8517 int _v;
8518 {
8519 void *ptr = 0;
8520 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8521 _v = 0;
8522 PyErr_Clear();
8523 } else {
8524 _v = (ptr != 0);
8525 }
8526 }
8527 if (_v) {
8528 return _wrap_new_TimerRunner__SWIG_0(self,args);
8529 }
8530 }
8531 if ((argc >= 2) && (argc <= 3)) {
8532 int _v;
8533 {
8534 void *ptr = 0;
8535 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8536 _v = 0;
8537 PyErr_Clear();
8538 } else {
8539 _v = (ptr != 0);
8540 }
8541 }
8542 if (_v) {
8543 _v = SWIG_Check_int(argv[1]);
8544 if (_v) {
8545 if (argc <= 2) {
8546 return _wrap_new_TimerRunner__SWIG_1(self,args);
8547 }
8548 _v = SWIG_Check_bool(argv[2]);
8549 if (_v) {
8550 return _wrap_new_TimerRunner__SWIG_1(self,args);
8551 }
8552 }
8553 }
8554 }
8555
8556 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8557 return NULL;
8558 }
8559
8560
8561 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8562 PyObject *resultobj;
8563 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8564 PyObject * obj0 = 0 ;
8565 char *kwnames[] = {
8566 (char *) "self", NULL
8567 };
8568
8569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8571 if (SWIG_arg_fail(1)) SWIG_fail;
8572 {
8573 PyThreadState* __tstate = wxPyBeginAllowThreads();
8574 delete arg1;
8575
8576 wxPyEndAllowThreads(__tstate);
8577 if (PyErr_Occurred()) SWIG_fail;
8578 }
8579 Py_INCREF(Py_None); resultobj = Py_None;
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj;
8588 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8589 int arg2 ;
8590 bool arg3 = (bool) false ;
8591 PyObject * obj0 = 0 ;
8592 PyObject * obj1 = 0 ;
8593 PyObject * obj2 = 0 ;
8594 char *kwnames[] = {
8595 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8596 };
8597
8598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8600 if (SWIG_arg_fail(1)) SWIG_fail;
8601 {
8602 arg2 = (int)(SWIG_As_int(obj1));
8603 if (SWIG_arg_fail(2)) SWIG_fail;
8604 }
8605 if (obj2) {
8606 {
8607 arg3 = (bool)(SWIG_As_bool(obj2));
8608 if (SWIG_arg_fail(3)) SWIG_fail;
8609 }
8610 }
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 (arg1)->Start(arg2,arg3);
8614
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 Py_INCREF(Py_None); resultobj = Py_None;
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8626 PyObject *obj;
8627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8628 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8629 Py_INCREF(obj);
8630 return Py_BuildValue((char *)"");
8631 }
8632 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj;
8634 wxLog *result;
8635 char *kwnames[] = {
8636 NULL
8637 };
8638
8639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8640 {
8641 PyThreadState* __tstate = wxPyBeginAllowThreads();
8642 result = (wxLog *)new wxLog();
8643
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj;
8656 bool result;
8657 char *kwnames[] = {
8658 NULL
8659 };
8660
8661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 result = (bool)wxLog::IsEnabled();
8665
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 {
8670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8671 }
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj;
8680 bool arg1 = (bool) true ;
8681 bool result;
8682 PyObject * obj0 = 0 ;
8683 char *kwnames[] = {
8684 (char *) "doIt", NULL
8685 };
8686
8687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8688 if (obj0) {
8689 {
8690 arg1 = (bool)(SWIG_As_bool(obj0));
8691 if (SWIG_arg_fail(1)) SWIG_fail;
8692 }
8693 }
8694 {
8695 PyThreadState* __tstate = wxPyBeginAllowThreads();
8696 result = (bool)wxLog::EnableLogging(arg1);
8697
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 {
8702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8703 }
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj;
8712 wxLogLevel arg1 ;
8713 wxChar *arg2 = (wxChar *) 0 ;
8714 time_t arg3 ;
8715 PyObject * obj0 = 0 ;
8716 PyObject * obj1 = 0 ;
8717 PyObject * obj2 = 0 ;
8718 char *kwnames[] = {
8719 (char *) "level",(char *) "szString",(char *) "t", NULL
8720 };
8721
8722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8723 {
8724 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8725 if (SWIG_arg_fail(1)) SWIG_fail;
8726 }
8727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(2)) SWIG_fail;
8729 {
8730 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8731 if (SWIG_arg_fail(3)) SWIG_fail;
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8736
8737 wxPyEndAllowThreads(__tstate);
8738 if (PyErr_Occurred()) SWIG_fail;
8739 }
8740 Py_INCREF(Py_None); resultobj = Py_None;
8741 return resultobj;
8742 fail:
8743 return NULL;
8744 }
8745
8746
8747 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8748 PyObject *resultobj;
8749 wxLog *arg1 = (wxLog *) 0 ;
8750 PyObject * obj0 = 0 ;
8751 char *kwnames[] = {
8752 (char *) "self", NULL
8753 };
8754
8755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8757 if (SWIG_arg_fail(1)) SWIG_fail;
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 (arg1)->Flush();
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 Py_INCREF(Py_None); resultobj = Py_None;
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj;
8774 char *kwnames[] = {
8775 NULL
8776 };
8777
8778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 wxLog::FlushActive();
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 Py_INCREF(Py_None); resultobj = Py_None;
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 wxLog *result;
8796 char *kwnames[] = {
8797 NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8801 {
8802 PyThreadState* __tstate = wxPyBeginAllowThreads();
8803 result = (wxLog *)wxLog::GetActiveTarget();
8804
8805 wxPyEndAllowThreads(__tstate);
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj;
8817 wxLog *arg1 = (wxLog *) 0 ;
8818 wxLog *result;
8819 PyObject * obj0 = 0 ;
8820 char *kwnames[] = {
8821 (char *) "pLogger", NULL
8822 };
8823
8824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8826 if (SWIG_arg_fail(1)) SWIG_fail;
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8830
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj;
8843 char *kwnames[] = {
8844 NULL
8845 };
8846
8847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8848 {
8849 PyThreadState* __tstate = wxPyBeginAllowThreads();
8850 wxLog::Suspend();
8851
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 Py_INCREF(Py_None); resultobj = Py_None;
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8863 PyObject *resultobj;
8864 char *kwnames[] = {
8865 NULL
8866 };
8867
8868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8869 {
8870 PyThreadState* __tstate = wxPyBeginAllowThreads();
8871 wxLog::Resume();
8872
8873 wxPyEndAllowThreads(__tstate);
8874 if (PyErr_Occurred()) SWIG_fail;
8875 }
8876 Py_INCREF(Py_None); resultobj = Py_None;
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8884 PyObject *resultobj;
8885 bool arg1 = (bool) true ;
8886 PyObject * obj0 = 0 ;
8887 char *kwnames[] = {
8888 (char *) "bVerbose", NULL
8889 };
8890
8891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8892 if (obj0) {
8893 {
8894 arg1 = (bool)(SWIG_As_bool(obj0));
8895 if (SWIG_arg_fail(1)) SWIG_fail;
8896 }
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 wxLog::SetVerbose(arg1);
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_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 wxLogLevel arg1 ;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "logLevel", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8921 {
8922 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8923 if (SWIG_arg_fail(1)) SWIG_fail;
8924 }
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 wxLog::SetLogLevel(arg1);
8928
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 Py_INCREF(Py_None); resultobj = Py_None;
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8940 PyObject *resultobj;
8941 char *kwnames[] = {
8942 NULL
8943 };
8944
8945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 wxLog::DontCreateOnDemand();
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 Py_INCREF(Py_None); resultobj = Py_None;
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8961 PyObject *resultobj;
8962 wxTraceMask arg1 ;
8963 PyObject * obj0 = 0 ;
8964 char *kwnames[] = {
8965 (char *) "ulMask", NULL
8966 };
8967
8968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8969 {
8970 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8971 if (SWIG_arg_fail(1)) SWIG_fail;
8972 }
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 wxLog::SetTraceMask(arg1);
8976
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 Py_INCREF(Py_None); resultobj = Py_None;
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj;
8989 wxString *arg1 = 0 ;
8990 bool temp1 = false ;
8991 PyObject * obj0 = 0 ;
8992 char *kwnames[] = {
8993 (char *) "str", NULL
8994 };
8995
8996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8997 {
8998 arg1 = wxString_in_helper(obj0);
8999 if (arg1 == NULL) SWIG_fail;
9000 temp1 = true;
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 wxLog::AddTraceMask((wxString const &)*arg1);
9005
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 Py_INCREF(Py_None); resultobj = Py_None;
9010 {
9011 if (temp1)
9012 delete arg1;
9013 }
9014 return resultobj;
9015 fail:
9016 {
9017 if (temp1)
9018 delete arg1;
9019 }
9020 return NULL;
9021 }
9022
9023
9024 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj;
9026 wxString *arg1 = 0 ;
9027 bool temp1 = false ;
9028 PyObject * obj0 = 0 ;
9029 char *kwnames[] = {
9030 (char *) "str", NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9034 {
9035 arg1 = wxString_in_helper(obj0);
9036 if (arg1 == NULL) SWIG_fail;
9037 temp1 = true;
9038 }
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 wxLog::RemoveTraceMask((wxString const &)*arg1);
9042
9043 wxPyEndAllowThreads(__tstate);
9044 if (PyErr_Occurred()) SWIG_fail;
9045 }
9046 Py_INCREF(Py_None); resultobj = Py_None;
9047 {
9048 if (temp1)
9049 delete arg1;
9050 }
9051 return resultobj;
9052 fail:
9053 {
9054 if (temp1)
9055 delete arg1;
9056 }
9057 return NULL;
9058 }
9059
9060
9061 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9062 PyObject *resultobj;
9063 char *kwnames[] = {
9064 NULL
9065 };
9066
9067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 wxLog::ClearTraceMasks();
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 Py_INCREF(Py_None); resultobj = Py_None;
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9083 PyObject *resultobj;
9084 wxArrayString *result;
9085 char *kwnames[] = {
9086 NULL
9087 };
9088
9089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 {
9093 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9094 result = (wxArrayString *) &_result_ref;
9095 }
9096
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 {
9101 resultobj = wxArrayString2PyList_helper(*result);
9102 }
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj;
9111 wxChar *arg1 = (wxChar *) 0 ;
9112 PyObject * obj0 = 0 ;
9113 char *kwnames[] = {
9114 (char *) "ts", NULL
9115 };
9116
9117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9119 if (SWIG_arg_fail(1)) SWIG_fail;
9120 {
9121 PyThreadState* __tstate = wxPyBeginAllowThreads();
9122 wxLog::SetTimestamp((wxChar const *)arg1);
9123
9124 wxPyEndAllowThreads(__tstate);
9125 if (PyErr_Occurred()) SWIG_fail;
9126 }
9127 Py_INCREF(Py_None); resultobj = Py_None;
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9135 PyObject *resultobj;
9136 bool result;
9137 char *kwnames[] = {
9138 NULL
9139 };
9140
9141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 result = (bool)wxLog::GetVerbose();
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 {
9150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9151 }
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj;
9160 wxTraceMask result;
9161 char *kwnames[] = {
9162 NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 result = (wxTraceMask)wxLog::GetTraceMask();
9169
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 {
9174 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9175 }
9176 return resultobj;
9177 fail:
9178 return NULL;
9179 }
9180
9181
9182 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj;
9184 wxChar *arg1 = (wxChar *) 0 ;
9185 bool result;
9186 PyObject * obj0 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "mask", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9193 if (SWIG_arg_fail(1)) SWIG_fail;
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9197
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 {
9202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9203 }
9204 return resultobj;
9205 fail:
9206 return NULL;
9207 }
9208
9209
9210 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9211 PyObject *resultobj;
9212 wxLogLevel result;
9213 char *kwnames[] = {
9214 NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 result = (wxLogLevel)wxLog::GetLogLevel();
9221
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 {
9226 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9227 }
9228 return resultobj;
9229 fail:
9230 return NULL;
9231 }
9232
9233
9234 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9235 PyObject *resultobj;
9236 wxChar *result;
9237 char *kwnames[] = {
9238 NULL
9239 };
9240
9241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 result = (wxChar *)wxLog::GetTimestamp();
9245
9246 wxPyEndAllowThreads(__tstate);
9247 if (PyErr_Occurred()) SWIG_fail;
9248 }
9249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9250 return resultobj;
9251 fail:
9252 return NULL;
9253 }
9254
9255
9256 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9257 PyObject *resultobj;
9258 wxString result;
9259 char *kwnames[] = {
9260 NULL
9261 };
9262
9263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = Log_TimeStamp();
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 {
9272 #if wxUSE_UNICODE
9273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9274 #else
9275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9276 #endif
9277 }
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 wxLog *arg1 = (wxLog *) 0 ;
9287 PyObject * obj0 = 0 ;
9288 char *kwnames[] = {
9289 (char *) "self", NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9294 if (SWIG_arg_fail(1)) SWIG_fail;
9295 {
9296 PyThreadState* __tstate = wxPyBeginAllowThreads();
9297 wxLog_Destroy(arg1);
9298
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 Py_INCREF(Py_None); resultobj = Py_None;
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9310 PyObject *obj;
9311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9312 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9313 Py_INCREF(obj);
9314 return Py_BuildValue((char *)"");
9315 }
9316 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9317 PyObject *resultobj;
9318 wxLogStderr *result;
9319 char *kwnames[] = {
9320 NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (wxLogStderr *)new wxLogStderr();
9327
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9339 PyObject *obj;
9340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9341 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9342 Py_INCREF(obj);
9343 return Py_BuildValue((char *)"");
9344 }
9345 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9346 PyObject *resultobj;
9347 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9348 wxLogTextCtrl *result;
9349 PyObject * obj0 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "pTextCtrl", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9372 PyObject *obj;
9373 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9374 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9375 Py_INCREF(obj);
9376 return Py_BuildValue((char *)"");
9377 }
9378 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxLogGui *result;
9381 char *kwnames[] = {
9382 NULL
9383 };
9384
9385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 result = (wxLogGui *)new wxLogGui();
9389
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9401 PyObject *obj;
9402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9403 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9404 Py_INCREF(obj);
9405 return Py_BuildValue((char *)"");
9406 }
9407 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 wxFrame *arg1 = (wxFrame *) 0 ;
9410 wxString *arg2 = 0 ;
9411 bool arg3 = (bool) true ;
9412 bool arg4 = (bool) true ;
9413 wxLogWindow *result;
9414 bool temp2 = false ;
9415 PyObject * obj0 = 0 ;
9416 PyObject * obj1 = 0 ;
9417 PyObject * obj2 = 0 ;
9418 PyObject * obj3 = 0 ;
9419 char *kwnames[] = {
9420 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9421 };
9422
9423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9425 if (SWIG_arg_fail(1)) SWIG_fail;
9426 {
9427 arg2 = wxString_in_helper(obj1);
9428 if (arg2 == NULL) SWIG_fail;
9429 temp2 = true;
9430 }
9431 if (obj2) {
9432 {
9433 arg3 = (bool)(SWIG_As_bool(obj2));
9434 if (SWIG_arg_fail(3)) SWIG_fail;
9435 }
9436 }
9437 if (obj3) {
9438 {
9439 arg4 = (bool)(SWIG_As_bool(obj3));
9440 if (SWIG_arg_fail(4)) SWIG_fail;
9441 }
9442 }
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9446
9447 wxPyEndAllowThreads(__tstate);
9448 if (PyErr_Occurred()) SWIG_fail;
9449 }
9450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9451 {
9452 if (temp2)
9453 delete arg2;
9454 }
9455 return resultobj;
9456 fail:
9457 {
9458 if (temp2)
9459 delete arg2;
9460 }
9461 return NULL;
9462 }
9463
9464
9465 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9466 PyObject *resultobj;
9467 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9468 bool arg2 = (bool) true ;
9469 PyObject * obj0 = 0 ;
9470 PyObject * obj1 = 0 ;
9471 char *kwnames[] = {
9472 (char *) "self",(char *) "bShow", NULL
9473 };
9474
9475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9477 if (SWIG_arg_fail(1)) SWIG_fail;
9478 if (obj1) {
9479 {
9480 arg2 = (bool)(SWIG_As_bool(obj1));
9481 if (SWIG_arg_fail(2)) SWIG_fail;
9482 }
9483 }
9484 {
9485 PyThreadState* __tstate = wxPyBeginAllowThreads();
9486 (arg1)->Show(arg2);
9487
9488 wxPyEndAllowThreads(__tstate);
9489 if (PyErr_Occurred()) SWIG_fail;
9490 }
9491 Py_INCREF(Py_None); resultobj = Py_None;
9492 return resultobj;
9493 fail:
9494 return NULL;
9495 }
9496
9497
9498 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9499 PyObject *resultobj;
9500 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9501 wxFrame *result;
9502 PyObject * obj0 = 0 ;
9503 char *kwnames[] = {
9504 (char *) "self", NULL
9505 };
9506
9507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9509 if (SWIG_arg_fail(1)) SWIG_fail;
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 {
9518 resultobj = wxPyMake_wxObject(result, 0);
9519 }
9520 return resultobj;
9521 fail:
9522 return NULL;
9523 }
9524
9525
9526 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj;
9528 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9529 wxLog *result;
9530 PyObject * obj0 = 0 ;
9531 char *kwnames[] = {
9532 (char *) "self", NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9537 if (SWIG_arg_fail(1)) SWIG_fail;
9538 {
9539 PyThreadState* __tstate = wxPyBeginAllowThreads();
9540 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9541
9542 wxPyEndAllowThreads(__tstate);
9543 if (PyErr_Occurred()) SWIG_fail;
9544 }
9545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9546 return resultobj;
9547 fail:
9548 return NULL;
9549 }
9550
9551
9552 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9553 PyObject *resultobj;
9554 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9555 bool result;
9556 PyObject * obj0 = 0 ;
9557 char *kwnames[] = {
9558 (char *) "self", NULL
9559 };
9560
9561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9563 if (SWIG_arg_fail(1)) SWIG_fail;
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9567
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 {
9572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9573 }
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj;
9582 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9583 bool arg2 ;
9584 PyObject * obj0 = 0 ;
9585 PyObject * obj1 = 0 ;
9586 char *kwnames[] = {
9587 (char *) "self",(char *) "bDoPass", NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9592 if (SWIG_arg_fail(1)) SWIG_fail;
9593 {
9594 arg2 = (bool)(SWIG_As_bool(obj1));
9595 if (SWIG_arg_fail(2)) SWIG_fail;
9596 }
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->PassMessages(arg2);
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 Py_INCREF(Py_None); resultobj = Py_None;
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9612 PyObject *obj;
9613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9614 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9615 Py_INCREF(obj);
9616 return Py_BuildValue((char *)"");
9617 }
9618 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj;
9620 wxLog *arg1 = (wxLog *) 0 ;
9621 wxLogChain *result;
9622 PyObject * obj0 = 0 ;
9623 char *kwnames[] = {
9624 (char *) "logger", NULL
9625 };
9626
9627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9629 if (SWIG_arg_fail(1)) SWIG_fail;
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxLogChain *)new wxLogChain(arg1);
9633
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9638 return resultobj;
9639 fail:
9640 return NULL;
9641 }
9642
9643
9644 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9645 PyObject *resultobj;
9646 wxLogChain *arg1 = (wxLogChain *) 0 ;
9647 wxLog *arg2 = (wxLog *) 0 ;
9648 PyObject * obj0 = 0 ;
9649 PyObject * obj1 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self",(char *) "logger", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9658 if (SWIG_arg_fail(2)) SWIG_fail;
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 (arg1)->SetLog(arg2);
9662
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 Py_INCREF(Py_None); resultobj = Py_None;
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxLogChain *arg1 = (wxLogChain *) 0 ;
9676 bool arg2 ;
9677 PyObject * obj0 = 0 ;
9678 PyObject * obj1 = 0 ;
9679 char *kwnames[] = {
9680 (char *) "self",(char *) "bDoPass", NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9685 if (SWIG_arg_fail(1)) SWIG_fail;
9686 {
9687 arg2 = (bool)(SWIG_As_bool(obj1));
9688 if (SWIG_arg_fail(2)) SWIG_fail;
9689 }
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 (arg1)->PassMessages(arg2);
9693
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 Py_INCREF(Py_None); resultobj = Py_None;
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxLogChain *arg1 = (wxLogChain *) 0 ;
9707 bool result;
9708 PyObject * obj0 = 0 ;
9709 char *kwnames[] = {
9710 (char *) "self", NULL
9711 };
9712
9713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9715 if (SWIG_arg_fail(1)) SWIG_fail;
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (bool)(arg1)->IsPassingMessages();
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 {
9724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9725 }
9726 return resultobj;
9727 fail:
9728 return NULL;
9729 }
9730
9731
9732 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9733 PyObject *resultobj;
9734 wxLogChain *arg1 = (wxLogChain *) 0 ;
9735 wxLog *result;
9736 PyObject * obj0 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 PyThreadState* __tstate = wxPyBeginAllowThreads();
9746 result = (wxLog *)(arg1)->GetOldLog();
9747
9748 wxPyEndAllowThreads(__tstate);
9749 if (PyErr_Occurred()) SWIG_fail;
9750 }
9751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9759 PyObject *obj;
9760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9761 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9762 Py_INCREF(obj);
9763 return Py_BuildValue((char *)"");
9764 }
9765 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9766 PyObject *resultobj;
9767 unsigned long result;
9768 char *kwnames[] = {
9769 NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 result = (unsigned long)wxSysErrorCode();
9776
9777 wxPyEndAllowThreads(__tstate);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 {
9781 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9782 }
9783 return resultobj;
9784 fail:
9785 return NULL;
9786 }
9787
9788
9789 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj;
9791 unsigned long arg1 = (unsigned long) 0 ;
9792 wxString result;
9793 PyObject * obj0 = 0 ;
9794 char *kwnames[] = {
9795 (char *) "nErrCode", NULL
9796 };
9797
9798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9799 if (obj0) {
9800 {
9801 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9802 if (SWIG_arg_fail(1)) SWIG_fail;
9803 }
9804 }
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 result = wxSysErrorMsg(arg1);
9808
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 {
9813 #if wxUSE_UNICODE
9814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9815 #else
9816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9817 #endif
9818 }
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9826 PyObject *resultobj;
9827 wxString *arg1 = 0 ;
9828 bool temp1 = false ;
9829 PyObject * obj0 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "msg", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9835 {
9836 arg1 = wxString_in_helper(obj0);
9837 if (arg1 == NULL) SWIG_fail;
9838 temp1 = true;
9839 }
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 wxPyLogFatalError((wxString const &)*arg1);
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 Py_INCREF(Py_None); resultobj = Py_None;
9848 {
9849 if (temp1)
9850 delete arg1;
9851 }
9852 return resultobj;
9853 fail:
9854 {
9855 if (temp1)
9856 delete arg1;
9857 }
9858 return NULL;
9859 }
9860
9861
9862 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj;
9864 wxString *arg1 = 0 ;
9865 bool temp1 = false ;
9866 PyObject * obj0 = 0 ;
9867 char *kwnames[] = {
9868 (char *) "msg", NULL
9869 };
9870
9871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9872 {
9873 arg1 = wxString_in_helper(obj0);
9874 if (arg1 == NULL) SWIG_fail;
9875 temp1 = true;
9876 }
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 wxPyLogError((wxString const &)*arg1);
9880
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 Py_INCREF(Py_None); resultobj = Py_None;
9885 {
9886 if (temp1)
9887 delete arg1;
9888 }
9889 return resultobj;
9890 fail:
9891 {
9892 if (temp1)
9893 delete arg1;
9894 }
9895 return NULL;
9896 }
9897
9898
9899 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxString *arg1 = 0 ;
9902 bool temp1 = false ;
9903 PyObject * obj0 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "msg", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9909 {
9910 arg1 = wxString_in_helper(obj0);
9911 if (arg1 == NULL) SWIG_fail;
9912 temp1 = true;
9913 }
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 wxPyLogWarning((wxString const &)*arg1);
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 Py_INCREF(Py_None); resultobj = Py_None;
9922 {
9923 if (temp1)
9924 delete arg1;
9925 }
9926 return resultobj;
9927 fail:
9928 {
9929 if (temp1)
9930 delete arg1;
9931 }
9932 return NULL;
9933 }
9934
9935
9936 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj;
9938 wxString *arg1 = 0 ;
9939 bool temp1 = false ;
9940 PyObject * obj0 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "msg", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9946 {
9947 arg1 = wxString_in_helper(obj0);
9948 if (arg1 == NULL) SWIG_fail;
9949 temp1 = true;
9950 }
9951 {
9952 PyThreadState* __tstate = wxPyBeginAllowThreads();
9953 wxPyLogMessage((wxString const &)*arg1);
9954
9955 wxPyEndAllowThreads(__tstate);
9956 if (PyErr_Occurred()) SWIG_fail;
9957 }
9958 Py_INCREF(Py_None); resultobj = Py_None;
9959 {
9960 if (temp1)
9961 delete arg1;
9962 }
9963 return resultobj;
9964 fail:
9965 {
9966 if (temp1)
9967 delete arg1;
9968 }
9969 return NULL;
9970 }
9971
9972
9973 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj;
9975 wxString *arg1 = 0 ;
9976 bool temp1 = false ;
9977 PyObject * obj0 = 0 ;
9978 char *kwnames[] = {
9979 (char *) "msg", NULL
9980 };
9981
9982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9983 {
9984 arg1 = wxString_in_helper(obj0);
9985 if (arg1 == NULL) SWIG_fail;
9986 temp1 = true;
9987 }
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 wxPyLogInfo((wxString const &)*arg1);
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 Py_INCREF(Py_None); resultobj = Py_None;
9996 {
9997 if (temp1)
9998 delete arg1;
9999 }
10000 return resultobj;
10001 fail:
10002 {
10003 if (temp1)
10004 delete arg1;
10005 }
10006 return NULL;
10007 }
10008
10009
10010 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10011 PyObject *resultobj;
10012 wxString *arg1 = 0 ;
10013 bool temp1 = false ;
10014 PyObject * obj0 = 0 ;
10015 char *kwnames[] = {
10016 (char *) "msg", NULL
10017 };
10018
10019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10020 {
10021 arg1 = wxString_in_helper(obj0);
10022 if (arg1 == NULL) SWIG_fail;
10023 temp1 = true;
10024 }
10025 {
10026 PyThreadState* __tstate = wxPyBeginAllowThreads();
10027 wxPyLogDebug((wxString const &)*arg1);
10028
10029 wxPyEndAllowThreads(__tstate);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 Py_INCREF(Py_None); resultobj = Py_None;
10033 {
10034 if (temp1)
10035 delete arg1;
10036 }
10037 return resultobj;
10038 fail:
10039 {
10040 if (temp1)
10041 delete arg1;
10042 }
10043 return NULL;
10044 }
10045
10046
10047 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj;
10049 wxString *arg1 = 0 ;
10050 bool temp1 = false ;
10051 PyObject * obj0 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "msg", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10057 {
10058 arg1 = wxString_in_helper(obj0);
10059 if (arg1 == NULL) SWIG_fail;
10060 temp1 = true;
10061 }
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 wxPyLogVerbose((wxString const &)*arg1);
10065
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 Py_INCREF(Py_None); resultobj = Py_None;
10070 {
10071 if (temp1)
10072 delete arg1;
10073 }
10074 return resultobj;
10075 fail:
10076 {
10077 if (temp1)
10078 delete arg1;
10079 }
10080 return NULL;
10081 }
10082
10083
10084 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj;
10086 wxString *arg1 = 0 ;
10087 bool temp1 = false ;
10088 PyObject * obj0 = 0 ;
10089 char *kwnames[] = {
10090 (char *) "msg", NULL
10091 };
10092
10093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10094 {
10095 arg1 = wxString_in_helper(obj0);
10096 if (arg1 == NULL) SWIG_fail;
10097 temp1 = true;
10098 }
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 wxPyLogStatus((wxString const &)*arg1);
10102
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 Py_INCREF(Py_None); resultobj = Py_None;
10107 {
10108 if (temp1)
10109 delete arg1;
10110 }
10111 return resultobj;
10112 fail:
10113 {
10114 if (temp1)
10115 delete arg1;
10116 }
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj;
10123 wxFrame *arg1 = (wxFrame *) 0 ;
10124 wxString *arg2 = 0 ;
10125 bool temp2 = false ;
10126 PyObject * obj0 = 0 ;
10127 PyObject * obj1 = 0 ;
10128 char *kwnames[] = {
10129 (char *) "pFrame",(char *) "msg", NULL
10130 };
10131
10132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10134 if (SWIG_arg_fail(1)) SWIG_fail;
10135 {
10136 arg2 = wxString_in_helper(obj1);
10137 if (arg2 == NULL) SWIG_fail;
10138 temp2 = true;
10139 }
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10143
10144 wxPyEndAllowThreads(__tstate);
10145 if (PyErr_Occurred()) SWIG_fail;
10146 }
10147 Py_INCREF(Py_None); resultobj = Py_None;
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return resultobj;
10153 fail:
10154 {
10155 if (temp2)
10156 delete arg2;
10157 }
10158 return NULL;
10159 }
10160
10161
10162 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj;
10164 wxString *arg1 = 0 ;
10165 bool temp1 = false ;
10166 PyObject * obj0 = 0 ;
10167 char *kwnames[] = {
10168 (char *) "msg", NULL
10169 };
10170
10171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10172 {
10173 arg1 = wxString_in_helper(obj0);
10174 if (arg1 == NULL) SWIG_fail;
10175 temp1 = true;
10176 }
10177 {
10178 PyThreadState* __tstate = wxPyBeginAllowThreads();
10179 wxPyLogSysError((wxString const &)*arg1);
10180
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 Py_INCREF(Py_None); resultobj = Py_None;
10185 {
10186 if (temp1)
10187 delete arg1;
10188 }
10189 return resultobj;
10190 fail:
10191 {
10192 if (temp1)
10193 delete arg1;
10194 }
10195 return NULL;
10196 }
10197
10198
10199 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10200 PyObject *resultobj;
10201 unsigned long arg1 ;
10202 wxString *arg2 = 0 ;
10203 bool temp2 = false ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char *kwnames[] = {
10207 (char *) "level",(char *) "msg", NULL
10208 };
10209
10210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10211 {
10212 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10213 if (SWIG_arg_fail(1)) SWIG_fail;
10214 }
10215 {
10216 arg2 = wxString_in_helper(obj1);
10217 if (arg2 == NULL) SWIG_fail;
10218 temp2 = true;
10219 }
10220 {
10221 PyThreadState* __tstate = wxPyBeginAllowThreads();
10222 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10223
10224 wxPyEndAllowThreads(__tstate);
10225 if (PyErr_Occurred()) SWIG_fail;
10226 }
10227 Py_INCREF(Py_None); resultobj = Py_None;
10228 {
10229 if (temp2)
10230 delete arg2;
10231 }
10232 return resultobj;
10233 fail:
10234 {
10235 if (temp2)
10236 delete arg2;
10237 }
10238 return NULL;
10239 }
10240
10241
10242 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10243 PyObject *resultobj;
10244 unsigned long arg1 ;
10245 wxString *arg2 = 0 ;
10246 bool temp2 = false ;
10247 PyObject * obj0 = 0 ;
10248 PyObject * obj1 = 0 ;
10249
10250 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10251 {
10252 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10253 if (SWIG_arg_fail(1)) SWIG_fail;
10254 }
10255 {
10256 arg2 = wxString_in_helper(obj1);
10257 if (arg2 == NULL) SWIG_fail;
10258 temp2 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 wxPyLogTrace(arg1,(wxString const &)*arg2);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10283 PyObject *resultobj;
10284 wxString *arg1 = 0 ;
10285 wxString *arg2 = 0 ;
10286 bool temp1 = false ;
10287 bool temp2 = false ;
10288 PyObject * obj0 = 0 ;
10289 PyObject * obj1 = 0 ;
10290
10291 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10292 {
10293 arg1 = wxString_in_helper(obj0);
10294 if (arg1 == NULL) SWIG_fail;
10295 temp1 = true;
10296 }
10297 {
10298 arg2 = wxString_in_helper(obj1);
10299 if (arg2 == NULL) SWIG_fail;
10300 temp2 = true;
10301 }
10302 {
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10305
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 Py_INCREF(Py_None); resultobj = Py_None;
10310 {
10311 if (temp1)
10312 delete arg1;
10313 }
10314 {
10315 if (temp2)
10316 delete arg2;
10317 }
10318 return resultobj;
10319 fail:
10320 {
10321 if (temp1)
10322 delete arg1;
10323 }
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return NULL;
10329 }
10330
10331
10332 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10333 int argc;
10334 PyObject *argv[3];
10335 int ii;
10336
10337 argc = PyObject_Length(args);
10338 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10339 argv[ii] = PyTuple_GetItem(args,ii);
10340 }
10341 if (argc == 2) {
10342 int _v;
10343 {
10344 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10345 }
10346 if (_v) {
10347 {
10348 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10349 }
10350 if (_v) {
10351 return _wrap_LogTrace__SWIG_1(self,args);
10352 }
10353 }
10354 }
10355 if (argc == 2) {
10356 int _v;
10357 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10358 if (_v) {
10359 {
10360 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10361 }
10362 if (_v) {
10363 return _wrap_LogTrace__SWIG_0(self,args);
10364 }
10365 }
10366 }
10367
10368 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxString *arg1 = 0 ;
10376 wxString *arg2 = 0 ;
10377 bool temp1 = false ;
10378 bool temp2 = false ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 char *kwnames[] = {
10382 (char *) "title",(char *) "text", NULL
10383 };
10384
10385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10386 {
10387 arg1 = wxString_in_helper(obj0);
10388 if (arg1 == NULL) SWIG_fail;
10389 temp1 = true;
10390 }
10391 {
10392 arg2 = wxString_in_helper(obj1);
10393 if (arg2 == NULL) SWIG_fail;
10394 temp2 = true;
10395 }
10396 {
10397 PyThreadState* __tstate = wxPyBeginAllowThreads();
10398 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10399
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 Py_INCREF(Py_None); resultobj = Py_None;
10404 {
10405 if (temp1)
10406 delete arg1;
10407 }
10408 {
10409 if (temp2)
10410 delete arg2;
10411 }
10412 return resultobj;
10413 fail:
10414 {
10415 if (temp1)
10416 delete arg1;
10417 }
10418 {
10419 if (temp2)
10420 delete arg2;
10421 }
10422 return NULL;
10423 }
10424
10425
10426 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10427 PyObject *resultobj;
10428 wxLogNull *result;
10429 char *kwnames[] = {
10430 NULL
10431 };
10432
10433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (wxLogNull *)new wxLogNull();
10437
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10442 return resultobj;
10443 fail:
10444 return NULL;
10445 }
10446
10447
10448 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj;
10450 wxLogNull *arg1 = (wxLogNull *) 0 ;
10451 PyObject * obj0 = 0 ;
10452 char *kwnames[] = {
10453 (char *) "self", NULL
10454 };
10455
10456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10458 if (SWIG_arg_fail(1)) SWIG_fail;
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 delete arg1;
10462
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 Py_INCREF(Py_None); resultobj = Py_None;
10467 return resultobj;
10468 fail:
10469 return NULL;
10470 }
10471
10472
10473 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10474 PyObject *obj;
10475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10476 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10477 Py_INCREF(obj);
10478 return Py_BuildValue((char *)"");
10479 }
10480 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10481 PyObject *resultobj;
10482 wxPyLog *result;
10483 char *kwnames[] = {
10484 NULL
10485 };
10486
10487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (wxPyLog *)new wxPyLog();
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10503 PyObject *resultobj;
10504 wxPyLog *arg1 = (wxPyLog *) 0 ;
10505 PyObject *arg2 = (PyObject *) 0 ;
10506 PyObject *arg3 = (PyObject *) 0 ;
10507 PyObject * obj0 = 0 ;
10508 PyObject * obj1 = 0 ;
10509 PyObject * obj2 = 0 ;
10510 char *kwnames[] = {
10511 (char *) "self",(char *) "self",(char *) "_class", NULL
10512 };
10513
10514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10516 if (SWIG_arg_fail(1)) SWIG_fail;
10517 arg2 = obj1;
10518 arg3 = obj2;
10519 {
10520 PyThreadState* __tstate = wxPyBeginAllowThreads();
10521 (arg1)->_setCallbackInfo(arg2,arg3);
10522
10523 wxPyEndAllowThreads(__tstate);
10524 if (PyErr_Occurred()) SWIG_fail;
10525 }
10526 Py_INCREF(Py_None); resultobj = Py_None;
10527 return resultobj;
10528 fail:
10529 return NULL;
10530 }
10531
10532
10533 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10534 PyObject *obj;
10535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10536 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10537 Py_INCREF(obj);
10538 return Py_BuildValue((char *)"");
10539 }
10540 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10541 PyObject *resultobj;
10542 int arg1 ;
10543 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10544 int arg3 = (int) wxKILL_NOCHILDREN ;
10545 wxKillError result;
10546 PyObject * obj0 = 0 ;
10547 PyObject * obj1 = 0 ;
10548 PyObject * obj2 = 0 ;
10549 char *kwnames[] = {
10550 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10551 };
10552
10553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10554 {
10555 arg1 = (int)(SWIG_As_int(obj0));
10556 if (SWIG_arg_fail(1)) SWIG_fail;
10557 }
10558 if (obj1) {
10559 {
10560 arg2 = (wxSignal)(SWIG_As_int(obj1));
10561 if (SWIG_arg_fail(2)) SWIG_fail;
10562 }
10563 }
10564 if (obj2) {
10565 {
10566 arg3 = (int)(SWIG_As_int(obj2));
10567 if (SWIG_arg_fail(3)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_From_int((result));
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 int arg1 ;
10587 bool result;
10588 PyObject * obj0 = 0 ;
10589 char *kwnames[] = {
10590 (char *) "pid", NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10594 {
10595 arg1 = (int)(SWIG_As_int(obj0));
10596 if (SWIG_arg_fail(1)) SWIG_fail;
10597 }
10598 {
10599 PyThreadState* __tstate = wxPyBeginAllowThreads();
10600 result = (bool)wxPyProcess::Exists(arg1);
10601
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 {
10606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10607 }
10608 return resultobj;
10609 fail:
10610 return NULL;
10611 }
10612
10613
10614 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10615 PyObject *resultobj;
10616 wxString *arg1 = 0 ;
10617 int arg2 = (int) wxEXEC_ASYNC ;
10618 wxPyProcess *result;
10619 bool temp1 = false ;
10620 PyObject * obj0 = 0 ;
10621 PyObject * obj1 = 0 ;
10622 char *kwnames[] = {
10623 (char *) "cmd",(char *) "flags", NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10627 {
10628 arg1 = wxString_in_helper(obj0);
10629 if (arg1 == NULL) SWIG_fail;
10630 temp1 = true;
10631 }
10632 if (obj1) {
10633 {
10634 arg2 = (int)(SWIG_As_int(obj1));
10635 if (SWIG_arg_fail(2)) SWIG_fail;
10636 }
10637 }
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10641
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10646 {
10647 if (temp1)
10648 delete arg1;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (temp1)
10654 delete arg1;
10655 }
10656 return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj;
10662 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10663 int arg2 = (int) -1 ;
10664 wxPyProcess *result;
10665 PyObject * obj0 = 0 ;
10666 PyObject * obj1 = 0 ;
10667 char *kwnames[] = {
10668 (char *) "parent",(char *) "id", NULL
10669 };
10670
10671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10672 if (obj0) {
10673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10674 if (SWIG_arg_fail(1)) SWIG_fail;
10675 }
10676 if (obj1) {
10677 {
10678 arg2 = (int)(SWIG_As_int(obj1));
10679 if (SWIG_arg_fail(2)) SWIG_fail;
10680 }
10681 }
10682 {
10683 PyThreadState* __tstate = wxPyBeginAllowThreads();
10684 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10685
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj;
10698 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10699 PyObject *arg2 = (PyObject *) 0 ;
10700 PyObject *arg3 = (PyObject *) 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 PyObject * obj2 = 0 ;
10704 char *kwnames[] = {
10705 (char *) "self",(char *) "self",(char *) "_class", NULL
10706 };
10707
10708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10710 if (SWIG_arg_fail(1)) SWIG_fail;
10711 arg2 = obj1;
10712 arg3 = obj2;
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 (arg1)->_setCallbackInfo(arg2,arg3);
10716
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 Py_INCREF(Py_None); resultobj = Py_None;
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj;
10729 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10730 int arg2 ;
10731 int arg3 ;
10732 PyObject * obj0 = 0 ;
10733 PyObject * obj1 = 0 ;
10734 PyObject * obj2 = 0 ;
10735 char *kwnames[] = {
10736 (char *) "self",(char *) "pid",(char *) "status", NULL
10737 };
10738
10739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10741 if (SWIG_arg_fail(1)) SWIG_fail;
10742 {
10743 arg2 = (int)(SWIG_As_int(obj1));
10744 if (SWIG_arg_fail(2)) SWIG_fail;
10745 }
10746 {
10747 arg3 = (int)(SWIG_As_int(obj2));
10748 if (SWIG_arg_fail(3)) SWIG_fail;
10749 }
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->base_OnTerminate(arg2,arg3);
10753
10754 wxPyEndAllowThreads(__tstate);
10755 if (PyErr_Occurred()) SWIG_fail;
10756 }
10757 Py_INCREF(Py_None); resultobj = Py_None;
10758 return resultobj;
10759 fail:
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj;
10766 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10767 PyObject * obj0 = 0 ;
10768 char *kwnames[] = {
10769 (char *) "self", NULL
10770 };
10771
10772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10774 if (SWIG_arg_fail(1)) SWIG_fail;
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 (arg1)->Redirect();
10778
10779 wxPyEndAllowThreads(__tstate);
10780 if (PyErr_Occurred()) SWIG_fail;
10781 }
10782 Py_INCREF(Py_None); resultobj = Py_None;
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj;
10791 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10792 bool result;
10793 PyObject * obj0 = 0 ;
10794 char *kwnames[] = {
10795 (char *) "self", NULL
10796 };
10797
10798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (bool)(arg1)->IsRedirected();
10804
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 {
10809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10810 }
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj;
10819 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10820 PyObject * obj0 = 0 ;
10821 char *kwnames[] = {
10822 (char *) "self", NULL
10823 };
10824
10825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10827 if (SWIG_arg_fail(1)) SWIG_fail;
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 (arg1)->Detach();
10831
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 Py_INCREF(Py_None); resultobj = Py_None;
10836 return resultobj;
10837 fail:
10838 return NULL;
10839 }
10840
10841
10842 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj;
10844 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10845 wxInputStream *result;
10846 PyObject * obj0 = 0 ;
10847 char *kwnames[] = {
10848 (char *) "self", NULL
10849 };
10850
10851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10853 if (SWIG_arg_fail(1)) SWIG_fail;
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 result = (wxInputStream *)(arg1)->GetInputStream();
10857
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 {
10862 wxPyInputStream * _ptr = NULL;
10863
10864 if (result) {
10865 _ptr = new wxPyInputStream(result);
10866 }
10867 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10868 }
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj;
10877 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10878 wxInputStream *result;
10879 PyObject * obj0 = 0 ;
10880 char *kwnames[] = {
10881 (char *) "self", NULL
10882 };
10883
10884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10886 if (SWIG_arg_fail(1)) SWIG_fail;
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 result = (wxInputStream *)(arg1)->GetErrorStream();
10890
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 {
10895 wxPyInputStream * _ptr = NULL;
10896
10897 if (result) {
10898 _ptr = new wxPyInputStream(result);
10899 }
10900 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10901 }
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10909 PyObject *resultobj;
10910 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10911 wxOutputStream *result;
10912 PyObject * obj0 = 0 ;
10913 char *kwnames[] = {
10914 (char *) "self", NULL
10915 };
10916
10917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10919 if (SWIG_arg_fail(1)) SWIG_fail;
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxOutputStream *)(arg1)->GetOutputStream();
10923
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj;
10936 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10937 PyObject * obj0 = 0 ;
10938 char *kwnames[] = {
10939 (char *) "self", NULL
10940 };
10941
10942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10944 if (SWIG_arg_fail(1)) SWIG_fail;
10945 {
10946 PyThreadState* __tstate = wxPyBeginAllowThreads();
10947 (arg1)->CloseOutput();
10948
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 Py_INCREF(Py_None); resultobj = Py_None;
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj;
10961 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10962 bool result;
10963 PyObject * obj0 = 0 ;
10964 char *kwnames[] = {
10965 (char *) "self", NULL
10966 };
10967
10968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10970 if (SWIG_arg_fail(1)) SWIG_fail;
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10974
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 {
10979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10980 }
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10988 PyObject *resultobj;
10989 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10990 bool result;
10991 PyObject * obj0 = 0 ;
10992 char *kwnames[] = {
10993 (char *) "self", NULL
10994 };
10995
10996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(1)) SWIG_fail;
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11002
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11018 bool result;
11019 PyObject * obj0 = 0 ;
11020 char *kwnames[] = {
11021 (char *) "self", NULL
11022 };
11023
11024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11026 if (SWIG_arg_fail(1)) SWIG_fail;
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11030
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 {
11035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11036 }
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11044 PyObject *obj;
11045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11046 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11047 Py_INCREF(obj);
11048 return Py_BuildValue((char *)"");
11049 }
11050 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11051 PyObject *resultobj;
11052 int arg1 = (int) 0 ;
11053 int arg2 = (int) 0 ;
11054 int arg3 = (int) 0 ;
11055 wxProcessEvent *result;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11064 if (obj0) {
11065 {
11066 arg1 = (int)(SWIG_As_int(obj0));
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 }
11069 }
11070 if (obj1) {
11071 {
11072 arg2 = (int)(SWIG_As_int(obj1));
11073 if (SWIG_arg_fail(2)) SWIG_fail;
11074 }
11075 }
11076 if (obj2) {
11077 {
11078 arg3 = (int)(SWIG_As_int(obj2));
11079 if (SWIG_arg_fail(3)) SWIG_fail;
11080 }
11081 }
11082 {
11083 PyThreadState* __tstate = wxPyBeginAllowThreads();
11084 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11085
11086 wxPyEndAllowThreads(__tstate);
11087 if (PyErr_Occurred()) SWIG_fail;
11088 }
11089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj;
11098 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11099 int result;
11100 PyObject * obj0 = 0 ;
11101 char *kwnames[] = {
11102 (char *) "self", NULL
11103 };
11104
11105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11107 if (SWIG_arg_fail(1)) SWIG_fail;
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 result = (int)(arg1)->GetPid();
11111
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 {
11116 resultobj = SWIG_From_int((int)(result));
11117 }
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11125 PyObject *resultobj;
11126 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11127 int result;
11128 PyObject * obj0 = 0 ;
11129 char *kwnames[] = {
11130 (char *) "self", NULL
11131 };
11132
11133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11135 if (SWIG_arg_fail(1)) SWIG_fail;
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (int)(arg1)->GetExitCode();
11139
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 {
11144 resultobj = SWIG_From_int((int)(result));
11145 }
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj;
11154 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11155 int arg2 ;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11158 char *kwnames[] = {
11159 (char *) "self",(char *) "m_pid", NULL
11160 };
11161
11162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11164 if (SWIG_arg_fail(1)) SWIG_fail;
11165 {
11166 arg2 = (int)(SWIG_As_int(obj1));
11167 if (SWIG_arg_fail(2)) SWIG_fail;
11168 }
11169 if (arg1) (arg1)->m_pid = arg2;
11170
11171 Py_INCREF(Py_None); resultobj = Py_None;
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11179 PyObject *resultobj;
11180 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11181 int result;
11182 PyObject * obj0 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 result = (int) ((arg1)->m_pid);
11191
11192 {
11193 resultobj = SWIG_From_int((int)(result));
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj;
11203 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11204 int arg2 ;
11205 PyObject * obj0 = 0 ;
11206 PyObject * obj1 = 0 ;
11207 char *kwnames[] = {
11208 (char *) "self",(char *) "m_exitcode", NULL
11209 };
11210
11211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11213 if (SWIG_arg_fail(1)) SWIG_fail;
11214 {
11215 arg2 = (int)(SWIG_As_int(obj1));
11216 if (SWIG_arg_fail(2)) SWIG_fail;
11217 }
11218 if (arg1) (arg1)->m_exitcode = arg2;
11219
11220 Py_INCREF(Py_None); resultobj = Py_None;
11221 return resultobj;
11222 fail:
11223 return NULL;
11224 }
11225
11226
11227 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11228 PyObject *resultobj;
11229 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11230 int result;
11231 PyObject * obj0 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 result = (int) ((arg1)->m_exitcode);
11240
11241 {
11242 resultobj = SWIG_From_int((int)(result));
11243 }
11244 return resultobj;
11245 fail:
11246 return NULL;
11247 }
11248
11249
11250 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11251 PyObject *obj;
11252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11253 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11254 Py_INCREF(obj);
11255 return Py_BuildValue((char *)"");
11256 }
11257 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj;
11259 wxString *arg1 = 0 ;
11260 int arg2 = (int) wxEXEC_ASYNC ;
11261 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11262 long result;
11263 bool temp1 = false ;
11264 PyObject * obj0 = 0 ;
11265 PyObject * obj1 = 0 ;
11266 PyObject * obj2 = 0 ;
11267 char *kwnames[] = {
11268 (char *) "command",(char *) "flags",(char *) "process", NULL
11269 };
11270
11271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11272 {
11273 arg1 = wxString_in_helper(obj0);
11274 if (arg1 == NULL) SWIG_fail;
11275 temp1 = true;
11276 }
11277 if (obj1) {
11278 {
11279 arg2 = (int)(SWIG_As_int(obj1));
11280 if (SWIG_arg_fail(2)) SWIG_fail;
11281 }
11282 }
11283 if (obj2) {
11284 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(3)) SWIG_fail;
11286 }
11287 {
11288 if (!wxPyCheckForApp()) SWIG_fail;
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 {
11296 resultobj = SWIG_From_long((long)(result));
11297 }
11298 {
11299 if (temp1)
11300 delete arg1;
11301 }
11302 return resultobj;
11303 fail:
11304 {
11305 if (temp1)
11306 delete arg1;
11307 }
11308 return NULL;
11309 }
11310
11311
11312 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11313 PyObject *resultobj;
11314 long arg1 ;
11315 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11316 wxKillError *arg3 = (wxKillError *) 0 ;
11317 int arg4 = (int) wxKILL_NOCHILDREN ;
11318 int result;
11319 wxKillError temp3 ;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 PyObject * obj2 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11325 };
11326
11327 {
11328 arg3 = &temp3;
11329 }
11330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11331 {
11332 arg1 = (long)(SWIG_As_long(obj0));
11333 if (SWIG_arg_fail(1)) SWIG_fail;
11334 }
11335 if (obj1) {
11336 {
11337 arg2 = (wxSignal)(SWIG_As_int(obj1));
11338 if (SWIG_arg_fail(2)) SWIG_fail;
11339 }
11340 }
11341 if (obj2) {
11342 {
11343 arg4 = (int)(SWIG_As_int(obj2));
11344 if (SWIG_arg_fail(4)) SWIG_fail;
11345 }
11346 }
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11350
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 {
11355 resultobj = SWIG_From_int((int)(result));
11356 }
11357 {
11358 PyObject* o;
11359 o = PyInt_FromLong((long) (*arg3));
11360 resultobj = t_output_helper(resultobj, o);
11361 }
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 int arg1 = (int) wxJOYSTICK1 ;
11371 wxJoystick *result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "joystick", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11378 if (obj0) {
11379 {
11380 arg1 = (int)(SWIG_As_int(obj0));
11381 if (SWIG_arg_fail(1)) SWIG_fail;
11382 }
11383 }
11384 {
11385 if (!wxPyCheckForApp()) SWIG_fail;
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 result = (wxJoystick *)new wxJoystick(arg1);
11388
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11393 return resultobj;
11394 fail:
11395 return NULL;
11396 }
11397
11398
11399 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11400 PyObject *resultobj;
11401 wxJoystick *arg1 = (wxJoystick *) 0 ;
11402 PyObject * obj0 = 0 ;
11403 char *kwnames[] = {
11404 (char *) "self", NULL
11405 };
11406
11407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11409 if (SWIG_arg_fail(1)) SWIG_fail;
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 delete arg1;
11413
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 Py_INCREF(Py_None); resultobj = Py_None;
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxJoystick *arg1 = (wxJoystick *) 0 ;
11427 wxPoint result;
11428 PyObject * obj0 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "self", NULL
11431 };
11432
11433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(1)) SWIG_fail;
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (arg1)->GetPosition();
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 {
11444 wxPoint * resultptr;
11445 resultptr = new wxPoint((wxPoint &)(result));
11446 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11447 }
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11455 PyObject *resultobj;
11456 wxJoystick *arg1 = (wxJoystick *) 0 ;
11457 int result;
11458 PyObject * obj0 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "self", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11465 if (SWIG_arg_fail(1)) SWIG_fail;
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 result = (int)(arg1)->GetZPosition();
11469
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 {
11474 resultobj = SWIG_From_int((int)(result));
11475 }
11476 return resultobj;
11477 fail:
11478 return NULL;
11479 }
11480
11481
11482 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11483 PyObject *resultobj;
11484 wxJoystick *arg1 = (wxJoystick *) 0 ;
11485 int result;
11486 PyObject * obj0 = 0 ;
11487 char *kwnames[] = {
11488 (char *) "self", NULL
11489 };
11490
11491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11493 if (SWIG_arg_fail(1)) SWIG_fail;
11494 {
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 result = (int)(arg1)->GetButtonState();
11497
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 {
11502 resultobj = SWIG_From_int((int)(result));
11503 }
11504 return resultobj;
11505 fail:
11506 return NULL;
11507 }
11508
11509
11510 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11511 PyObject *resultobj;
11512 wxJoystick *arg1 = (wxJoystick *) 0 ;
11513 int result;
11514 PyObject * obj0 = 0 ;
11515 char *kwnames[] = {
11516 (char *) "self", NULL
11517 };
11518
11519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11521 if (SWIG_arg_fail(1)) SWIG_fail;
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 result = (int)(arg1)->GetPOVPosition();
11525
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 {
11530 resultobj = SWIG_From_int((int)(result));
11531 }
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11539 PyObject *resultobj;
11540 wxJoystick *arg1 = (wxJoystick *) 0 ;
11541 int result;
11542 PyObject * obj0 = 0 ;
11543 char *kwnames[] = {
11544 (char *) "self", NULL
11545 };
11546
11547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11549 if (SWIG_arg_fail(1)) SWIG_fail;
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (int)(arg1)->GetPOVCTSPosition();
11553
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = SWIG_From_int((int)(result));
11559 }
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj;
11568 wxJoystick *arg1 = (wxJoystick *) 0 ;
11569 int result;
11570 PyObject * obj0 = 0 ;
11571 char *kwnames[] = {
11572 (char *) "self", NULL
11573 };
11574
11575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11577 if (SWIG_arg_fail(1)) SWIG_fail;
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = (int)(arg1)->GetRudderPosition();
11581
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 {
11586 resultobj = SWIG_From_int((int)(result));
11587 }
11588 return resultobj;
11589 fail:
11590 return NULL;
11591 }
11592
11593
11594 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11595 PyObject *resultobj;
11596 wxJoystick *arg1 = (wxJoystick *) 0 ;
11597 int result;
11598 PyObject * obj0 = 0 ;
11599 char *kwnames[] = {
11600 (char *) "self", NULL
11601 };
11602
11603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11605 if (SWIG_arg_fail(1)) SWIG_fail;
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (int)(arg1)->GetUPosition();
11609
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = SWIG_From_int((int)(result));
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj;
11624 wxJoystick *arg1 = (wxJoystick *) 0 ;
11625 int result;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "self", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11633 if (SWIG_arg_fail(1)) SWIG_fail;
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (int)(arg1)->GetVPosition();
11637
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 resultobj = SWIG_From_int((int)(result));
11643 }
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11651 PyObject *resultobj;
11652 wxJoystick *arg1 = (wxJoystick *) 0 ;
11653 int result;
11654 PyObject * obj0 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (int)(arg1)->GetMovementThreshold();
11665
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = SWIG_From_int((int)(result));
11671 }
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj;
11680 wxJoystick *arg1 = (wxJoystick *) 0 ;
11681 int arg2 ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self",(char *) "threshold", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 arg2 = (int)(SWIG_As_int(obj1));
11693 if (SWIG_arg_fail(2)) SWIG_fail;
11694 }
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 (arg1)->SetMovementThreshold(arg2);
11698
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 Py_INCREF(Py_None); resultobj = Py_None;
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11710 PyObject *resultobj;
11711 wxJoystick *arg1 = (wxJoystick *) 0 ;
11712 bool result;
11713 PyObject * obj0 = 0 ;
11714 char *kwnames[] = {
11715 (char *) "self", NULL
11716 };
11717
11718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11720 if (SWIG_arg_fail(1)) SWIG_fail;
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 result = (bool)(arg1)->IsOk();
11724
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11730 }
11731 return resultobj;
11732 fail:
11733 return NULL;
11734 }
11735
11736
11737 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11738 PyObject *resultobj;
11739 wxJoystick *arg1 = (wxJoystick *) 0 ;
11740 int result;
11741 PyObject * obj0 = 0 ;
11742 char *kwnames[] = {
11743 (char *) "self", NULL
11744 };
11745
11746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11748 if (SWIG_arg_fail(1)) SWIG_fail;
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (int)(arg1)->GetNumberJoysticks();
11752
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 {
11757 resultobj = SWIG_From_int((int)(result));
11758 }
11759 return resultobj;
11760 fail:
11761 return NULL;
11762 }
11763
11764
11765 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj;
11767 wxJoystick *arg1 = (wxJoystick *) 0 ;
11768 int result;
11769 PyObject * obj0 = 0 ;
11770 char *kwnames[] = {
11771 (char *) "self", NULL
11772 };
11773
11774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11776 if (SWIG_arg_fail(1)) SWIG_fail;
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (int)(arg1)->GetManufacturerId();
11780
11781 wxPyEndAllowThreads(__tstate);
11782 if (PyErr_Occurred()) SWIG_fail;
11783 }
11784 {
11785 resultobj = SWIG_From_int((int)(result));
11786 }
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11794 PyObject *resultobj;
11795 wxJoystick *arg1 = (wxJoystick *) 0 ;
11796 int result;
11797 PyObject * obj0 = 0 ;
11798 char *kwnames[] = {
11799 (char *) "self", NULL
11800 };
11801
11802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11804 if (SWIG_arg_fail(1)) SWIG_fail;
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (int)(arg1)->GetProductId();
11808
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 {
11813 resultobj = SWIG_From_int((int)(result));
11814 }
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj;
11823 wxJoystick *arg1 = (wxJoystick *) 0 ;
11824 wxString result;
11825 PyObject * obj0 = 0 ;
11826 char *kwnames[] = {
11827 (char *) "self", NULL
11828 };
11829
11830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11832 if (SWIG_arg_fail(1)) SWIG_fail;
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (arg1)->GetProductName();
11836
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 #if wxUSE_UNICODE
11842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11843 #else
11844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11845 #endif
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj;
11855 wxJoystick *arg1 = (wxJoystick *) 0 ;
11856 int result;
11857 PyObject * obj0 = 0 ;
11858 char *kwnames[] = {
11859 (char *) "self", NULL
11860 };
11861
11862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11864 if (SWIG_arg_fail(1)) SWIG_fail;
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (int)(arg1)->GetXMin();
11868
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 {
11873 resultobj = SWIG_From_int((int)(result));
11874 }
11875 return resultobj;
11876 fail:
11877 return NULL;
11878 }
11879
11880
11881 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj;
11883 wxJoystick *arg1 = (wxJoystick *) 0 ;
11884 int result;
11885 PyObject * obj0 = 0 ;
11886 char *kwnames[] = {
11887 (char *) "self", NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11892 if (SWIG_arg_fail(1)) SWIG_fail;
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (int)(arg1)->GetYMin();
11896
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = SWIG_From_int((int)(result));
11902 }
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj;
11911 wxJoystick *arg1 = (wxJoystick *) 0 ;
11912 int result;
11913 PyObject * obj0 = 0 ;
11914 char *kwnames[] = {
11915 (char *) "self", NULL
11916 };
11917
11918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11920 if (SWIG_arg_fail(1)) SWIG_fail;
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 result = (int)(arg1)->GetZMin();
11924
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 {
11929 resultobj = SWIG_From_int((int)(result));
11930 }
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxJoystick *arg1 = (wxJoystick *) 0 ;
11940 int result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (int)(arg1)->GetXMax();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = SWIG_From_int((int)(result));
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxJoystick *arg1 = (wxJoystick *) 0 ;
11968 int result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (int)(arg1)->GetYMax();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = SWIG_From_int((int)(result));
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxJoystick *arg1 = (wxJoystick *) 0 ;
11996 int result;
11997 PyObject * obj0 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (int)(arg1)->GetZMax();
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = SWIG_From_int((int)(result));
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxJoystick *arg1 = (wxJoystick *) 0 ;
12024 int result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (int)(arg1)->GetNumberButtons();
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 resultobj = SWIG_From_int((int)(result));
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxJoystick *arg1 = (wxJoystick *) 0 ;
12052 int result;
12053 PyObject * obj0 = 0 ;
12054 char *kwnames[] = {
12055 (char *) "self", NULL
12056 };
12057
12058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12060 if (SWIG_arg_fail(1)) SWIG_fail;
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (int)(arg1)->GetNumberAxes();
12064
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 {
12069 resultobj = SWIG_From_int((int)(result));
12070 }
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12078 PyObject *resultobj;
12079 wxJoystick *arg1 = (wxJoystick *) 0 ;
12080 int result;
12081 PyObject * obj0 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "self", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12088 if (SWIG_arg_fail(1)) SWIG_fail;
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 result = (int)(arg1)->GetMaxButtons();
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 {
12097 resultobj = SWIG_From_int((int)(result));
12098 }
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj;
12107 wxJoystick *arg1 = (wxJoystick *) 0 ;
12108 int result;
12109 PyObject * obj0 = 0 ;
12110 char *kwnames[] = {
12111 (char *) "self", NULL
12112 };
12113
12114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12116 if (SWIG_arg_fail(1)) SWIG_fail;
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (int)(arg1)->GetMaxAxes();
12120
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = SWIG_From_int((int)(result));
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj;
12135 wxJoystick *arg1 = (wxJoystick *) 0 ;
12136 int result;
12137 PyObject * obj0 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (int)(arg1)->GetPollingMin();
12148
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 {
12153 resultobj = SWIG_From_int((int)(result));
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxJoystick *arg1 = (wxJoystick *) 0 ;
12164 int result;
12165 PyObject * obj0 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (int)(arg1)->GetPollingMax();
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = SWIG_From_int((int)(result));
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxJoystick *arg1 = (wxJoystick *) 0 ;
12192 int result;
12193 PyObject * obj0 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (int)(arg1)->GetRudderMin();
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 {
12209 resultobj = SWIG_From_int((int)(result));
12210 }
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxJoystick *arg1 = (wxJoystick *) 0 ;
12220 int result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (int)(arg1)->GetRudderMax();
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = SWIG_From_int((int)(result));
12238 }
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxJoystick *arg1 = (wxJoystick *) 0 ;
12248 int result;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (int)(arg1)->GetUMin();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = SWIG_From_int((int)(result));
12266 }
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxJoystick *arg1 = (wxJoystick *) 0 ;
12276 int result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->GetUMax();
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = SWIG_From_int((int)(result));
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxJoystick *arg1 = (wxJoystick *) 0 ;
12304 int result;
12305 PyObject * obj0 = 0 ;
12306 char *kwnames[] = {
12307 (char *) "self", NULL
12308 };
12309
12310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12312 if (SWIG_arg_fail(1)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (int)(arg1)->GetVMin();
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = SWIG_From_int((int)(result));
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxJoystick *arg1 = (wxJoystick *) 0 ;
12332 int result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (int)(arg1)->GetVMax();
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = SWIG_From_int((int)(result));
12350 }
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj;
12359 wxJoystick *arg1 = (wxJoystick *) 0 ;
12360 bool result;
12361 PyObject * obj0 = 0 ;
12362 char *kwnames[] = {
12363 (char *) "self", NULL
12364 };
12365
12366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(1)) SWIG_fail;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (bool)(arg1)->HasRudder();
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj;
12387 wxJoystick *arg1 = (wxJoystick *) 0 ;
12388 bool result;
12389 PyObject * obj0 = 0 ;
12390 char *kwnames[] = {
12391 (char *) "self", NULL
12392 };
12393
12394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12396 if (SWIG_arg_fail(1)) SWIG_fail;
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 result = (bool)(arg1)->HasZ();
12400
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 {
12405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxJoystick *arg1 = (wxJoystick *) 0 ;
12416 bool result;
12417 PyObject * obj0 = 0 ;
12418 char *kwnames[] = {
12419 (char *) "self", NULL
12420 };
12421
12422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12424 if (SWIG_arg_fail(1)) SWIG_fail;
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 result = (bool)(arg1)->HasU();
12428
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 {
12433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12434 }
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj;
12443 wxJoystick *arg1 = (wxJoystick *) 0 ;
12444 bool result;
12445 PyObject * obj0 = 0 ;
12446 char *kwnames[] = {
12447 (char *) "self", NULL
12448 };
12449
12450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12452 if (SWIG_arg_fail(1)) SWIG_fail;
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (bool)(arg1)->HasV();
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12462 }
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj;
12471 wxJoystick *arg1 = (wxJoystick *) 0 ;
12472 bool result;
12473 PyObject * obj0 = 0 ;
12474 char *kwnames[] = {
12475 (char *) "self", NULL
12476 };
12477
12478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12480 if (SWIG_arg_fail(1)) SWIG_fail;
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (bool)(arg1)->HasPOV();
12484
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12490 }
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj;
12499 wxJoystick *arg1 = (wxJoystick *) 0 ;
12500 bool result;
12501 PyObject * obj0 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (bool)(arg1)->HasPOV4Dir();
12512
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12518 }
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj;
12527 wxJoystick *arg1 = (wxJoystick *) 0 ;
12528 bool result;
12529 PyObject * obj0 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (bool)(arg1)->HasPOVCTS();
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxJoystick *arg1 = (wxJoystick *) 0 ;
12556 wxWindow *arg2 = (wxWindow *) 0 ;
12557 int arg3 = (int) 0 ;
12558 bool result;
12559 PyObject * obj0 = 0 ;
12560 PyObject * obj1 = 0 ;
12561 PyObject * obj2 = 0 ;
12562 char *kwnames[] = {
12563 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12564 };
12565
12566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12568 if (SWIG_arg_fail(1)) SWIG_fail;
12569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12570 if (SWIG_arg_fail(2)) SWIG_fail;
12571 if (obj2) {
12572 {
12573 arg3 = (int)(SWIG_As_int(obj2));
12574 if (SWIG_arg_fail(3)) SWIG_fail;
12575 }
12576 }
12577 {
12578 PyThreadState* __tstate = wxPyBeginAllowThreads();
12579 result = (bool)(arg1)->SetCapture(arg2,arg3);
12580
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 {
12585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12586 }
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj;
12595 wxJoystick *arg1 = (wxJoystick *) 0 ;
12596 bool result;
12597 PyObject * obj0 = 0 ;
12598 char *kwnames[] = {
12599 (char *) "self", NULL
12600 };
12601
12602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(1)) SWIG_fail;
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (bool)(arg1)->ReleaseCapture();
12608
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 {
12613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12614 }
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12622 PyObject *obj;
12623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12624 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12625 Py_INCREF(obj);
12626 return Py_BuildValue((char *)"");
12627 }
12628 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12631 int arg2 = (int) 0 ;
12632 int arg3 = (int) wxJOYSTICK1 ;
12633 int arg4 = (int) 0 ;
12634 wxJoystickEvent *result;
12635 PyObject * obj0 = 0 ;
12636 PyObject * obj1 = 0 ;
12637 PyObject * obj2 = 0 ;
12638 PyObject * obj3 = 0 ;
12639 char *kwnames[] = {
12640 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12641 };
12642
12643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12644 if (obj0) {
12645 {
12646 arg1 = (wxEventType)(SWIG_As_int(obj0));
12647 if (SWIG_arg_fail(1)) SWIG_fail;
12648 }
12649 }
12650 if (obj1) {
12651 {
12652 arg2 = (int)(SWIG_As_int(obj1));
12653 if (SWIG_arg_fail(2)) SWIG_fail;
12654 }
12655 }
12656 if (obj2) {
12657 {
12658 arg3 = (int)(SWIG_As_int(obj2));
12659 if (SWIG_arg_fail(3)) SWIG_fail;
12660 }
12661 }
12662 if (obj3) {
12663 {
12664 arg4 = (int)(SWIG_As_int(obj3));
12665 if (SWIG_arg_fail(4)) SWIG_fail;
12666 }
12667 }
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12671
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12676 return resultobj;
12677 fail:
12678 return NULL;
12679 }
12680
12681
12682 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12683 PyObject *resultobj;
12684 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12685 wxPoint result;
12686 PyObject * obj0 = 0 ;
12687 char *kwnames[] = {
12688 (char *) "self", NULL
12689 };
12690
12691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12693 if (SWIG_arg_fail(1)) SWIG_fail;
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12697
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 {
12702 wxPoint * resultptr;
12703 resultptr = new wxPoint((wxPoint &)(result));
12704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12715 int result;
12716 PyObject * obj0 = 0 ;
12717 char *kwnames[] = {
12718 (char *) "self", NULL
12719 };
12720
12721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12723 if (SWIG_arg_fail(1)) SWIG_fail;
12724 {
12725 PyThreadState* __tstate = wxPyBeginAllowThreads();
12726 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12727
12728 wxPyEndAllowThreads(__tstate);
12729 if (PyErr_Occurred()) SWIG_fail;
12730 }
12731 {
12732 resultobj = SWIG_From_int((int)(result));
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj;
12742 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12743 int result;
12744 PyObject * obj0 = 0 ;
12745 char *kwnames[] = {
12746 (char *) "self", NULL
12747 };
12748
12749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12751 if (SWIG_arg_fail(1)) SWIG_fail;
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 {
12760 resultobj = SWIG_From_int((int)(result));
12761 }
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12771 int result;
12772 PyObject * obj0 = 0 ;
12773 char *kwnames[] = {
12774 (char *) "self", NULL
12775 };
12776
12777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12779 if (SWIG_arg_fail(1)) SWIG_fail;
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12783
12784 wxPyEndAllowThreads(__tstate);
12785 if (PyErr_Occurred()) SWIG_fail;
12786 }
12787 {
12788 resultobj = SWIG_From_int((int)(result));
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj;
12798 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12799 int result;
12800 PyObject * obj0 = 0 ;
12801 char *kwnames[] = {
12802 (char *) "self", NULL
12803 };
12804
12805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12807 if (SWIG_arg_fail(1)) SWIG_fail;
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12811
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 {
12816 resultobj = SWIG_From_int((int)(result));
12817 }
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj;
12826 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12827 int arg2 ;
12828 PyObject * obj0 = 0 ;
12829 PyObject * obj1 = 0 ;
12830 char *kwnames[] = {
12831 (char *) "self",(char *) "stick", NULL
12832 };
12833
12834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12836 if (SWIG_arg_fail(1)) SWIG_fail;
12837 {
12838 arg2 = (int)(SWIG_As_int(obj1));
12839 if (SWIG_arg_fail(2)) SWIG_fail;
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 (arg1)->SetJoystick(arg2);
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 Py_INCREF(Py_None); resultobj = Py_None;
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj;
12857 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12858 int arg2 ;
12859 PyObject * obj0 = 0 ;
12860 PyObject * obj1 = 0 ;
12861 char *kwnames[] = {
12862 (char *) "self",(char *) "state", NULL
12863 };
12864
12865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12867 if (SWIG_arg_fail(1)) SWIG_fail;
12868 {
12869 arg2 = (int)(SWIG_As_int(obj1));
12870 if (SWIG_arg_fail(2)) SWIG_fail;
12871 }
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 (arg1)->SetButtonState(arg2);
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 Py_INCREF(Py_None); resultobj = Py_None;
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj;
12888 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12889 int arg2 ;
12890 PyObject * obj0 = 0 ;
12891 PyObject * obj1 = 0 ;
12892 char *kwnames[] = {
12893 (char *) "self",(char *) "change", NULL
12894 };
12895
12896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12898 if (SWIG_arg_fail(1)) SWIG_fail;
12899 {
12900 arg2 = (int)(SWIG_As_int(obj1));
12901 if (SWIG_arg_fail(2)) SWIG_fail;
12902 }
12903 {
12904 PyThreadState* __tstate = wxPyBeginAllowThreads();
12905 (arg1)->SetButtonChange(arg2);
12906
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 Py_INCREF(Py_None); resultobj = Py_None;
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12920 wxPoint *arg2 = 0 ;
12921 wxPoint temp2 ;
12922 PyObject * obj0 = 0 ;
12923 PyObject * obj1 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self",(char *) "pos", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 arg2 = &temp2;
12933 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 (arg1)->SetPosition((wxPoint const &)*arg2);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 Py_INCREF(Py_None); resultobj = Py_None;
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12952 int arg2 ;
12953 PyObject * obj0 = 0 ;
12954 PyObject * obj1 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self",(char *) "zPos", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 {
12963 arg2 = (int)(SWIG_As_int(obj1));
12964 if (SWIG_arg_fail(2)) SWIG_fail;
12965 }
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 (arg1)->SetZPosition(arg2);
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 Py_INCREF(Py_None); resultobj = Py_None;
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12981 PyObject *resultobj;
12982 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12983 bool result;
12984 PyObject * obj0 = 0 ;
12985 char *kwnames[] = {
12986 (char *) "self", NULL
12987 };
12988
12989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12991 if (SWIG_arg_fail(1)) SWIG_fail;
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12995
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 {
13000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13001 }
13002 return resultobj;
13003 fail:
13004 return NULL;
13005 }
13006
13007
13008 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13009 PyObject *resultobj;
13010 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13011 bool result;
13012 PyObject * obj0 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 {
13021 PyThreadState* __tstate = wxPyBeginAllowThreads();
13022 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13023
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 {
13028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13029 }
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13037 PyObject *resultobj;
13038 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13039 bool result;
13040 PyObject * obj0 = 0 ;
13041 char *kwnames[] = {
13042 (char *) "self", NULL
13043 };
13044
13045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13047 if (SWIG_arg_fail(1)) SWIG_fail;
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 {
13056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13057 }
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13065 PyObject *resultobj;
13066 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13067 int arg2 = (int) wxJOY_BUTTON_ANY ;
13068 bool result;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 char *kwnames[] = {
13072 (char *) "self",(char *) "but", NULL
13073 };
13074
13075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13077 if (SWIG_arg_fail(1)) SWIG_fail;
13078 if (obj1) {
13079 {
13080 arg2 = (int)(SWIG_As_int(obj1));
13081 if (SWIG_arg_fail(2)) SWIG_fail;
13082 }
13083 }
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13087
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 {
13092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13093 }
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13103 int arg2 = (int) wxJOY_BUTTON_ANY ;
13104 bool result;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self",(char *) "but", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 if (obj1) {
13115 {
13116 arg2 = (int)(SWIG_As_int(obj1));
13117 if (SWIG_arg_fail(2)) SWIG_fail;
13118 }
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13123
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 {
13128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13129 }
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj;
13138 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13139 int arg2 = (int) wxJOY_BUTTON_ANY ;
13140 bool result;
13141 PyObject * obj0 = 0 ;
13142 PyObject * obj1 = 0 ;
13143 char *kwnames[] = {
13144 (char *) "self",(char *) "but", NULL
13145 };
13146
13147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13149 if (SWIG_arg_fail(1)) SWIG_fail;
13150 if (obj1) {
13151 {
13152 arg2 = (int)(SWIG_As_int(obj1));
13153 if (SWIG_arg_fail(2)) SWIG_fail;
13154 }
13155 }
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13159
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 {
13164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13165 }
13166 return resultobj;
13167 fail:
13168 return NULL;
13169 }
13170
13171
13172 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13173 PyObject *obj;
13174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13175 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13176 Py_INCREF(obj);
13177 return Py_BuildValue((char *)"");
13178 }
13179 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13180 PyObject *resultobj;
13181 wxString const &arg1_defvalue = wxPyEmptyString ;
13182 wxString *arg1 = (wxString *) &arg1_defvalue ;
13183 wxSound *result;
13184 bool temp1 = false ;
13185 PyObject * obj0 = 0 ;
13186 char *kwnames[] = {
13187 (char *) "fileName", NULL
13188 };
13189
13190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13191 if (obj0) {
13192 {
13193 arg1 = wxString_in_helper(obj0);
13194 if (arg1 == NULL) SWIG_fail;
13195 temp1 = true;
13196 }
13197 }
13198 {
13199 if (!wxPyCheckForApp()) SWIG_fail;
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13202
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13207 {
13208 if (temp1)
13209 delete arg1;
13210 }
13211 return resultobj;
13212 fail:
13213 {
13214 if (temp1)
13215 delete arg1;
13216 }
13217 return NULL;
13218 }
13219
13220
13221 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13222 PyObject *resultobj;
13223 PyObject *arg1 = (PyObject *) 0 ;
13224 wxSound *result;
13225 PyObject * obj0 = 0 ;
13226 char *kwnames[] = {
13227 (char *) "data", NULL
13228 };
13229
13230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13231 arg1 = obj0;
13232 {
13233 if (!wxPyCheckForApp()) SWIG_fail;
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 result = (wxSound *)new_wxSound(arg1);
13236
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj;
13249 wxSound *arg1 = (wxSound *) 0 ;
13250 PyObject * obj0 = 0 ;
13251 char *kwnames[] = {
13252 (char *) "self", NULL
13253 };
13254
13255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13257 if (SWIG_arg_fail(1)) SWIG_fail;
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 delete arg1;
13261
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 Py_INCREF(Py_None); resultobj = Py_None;
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj;
13274 wxSound *arg1 = (wxSound *) 0 ;
13275 wxString *arg2 = 0 ;
13276 bool result;
13277 bool temp2 = false ;
13278 PyObject * obj0 = 0 ;
13279 PyObject * obj1 = 0 ;
13280 char *kwnames[] = {
13281 (char *) "self",(char *) "fileName", NULL
13282 };
13283
13284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13286 if (SWIG_arg_fail(1)) SWIG_fail;
13287 {
13288 arg2 = wxString_in_helper(obj1);
13289 if (arg2 == NULL) SWIG_fail;
13290 temp2 = true;
13291 }
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (bool)(arg1)->Create((wxString const &)*arg2);
13295
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 {
13300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13301 }
13302 {
13303 if (temp2)
13304 delete arg2;
13305 }
13306 return resultobj;
13307 fail:
13308 {
13309 if (temp2)
13310 delete arg2;
13311 }
13312 return NULL;
13313 }
13314
13315
13316 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj;
13318 wxSound *arg1 = (wxSound *) 0 ;
13319 PyObject *arg2 = (PyObject *) 0 ;
13320 bool result;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 char *kwnames[] = {
13324 (char *) "self",(char *) "data", NULL
13325 };
13326
13327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13329 if (SWIG_arg_fail(1)) SWIG_fail;
13330 arg2 = obj1;
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (bool)wxSound_CreateFromData(arg1,arg2);
13334
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 {
13339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13340 }
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13348 PyObject *resultobj;
13349 wxSound *arg1 = (wxSound *) 0 ;
13350 bool result;
13351 PyObject * obj0 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (bool)(arg1)->IsOk();
13362
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 {
13367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13368 }
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxSound *arg1 = (wxSound *) 0 ;
13378 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13379 bool result;
13380 PyObject * obj0 = 0 ;
13381 PyObject * obj1 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "self",(char *) "flags", NULL
13384 };
13385
13386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13388 if (SWIG_arg_fail(1)) SWIG_fail;
13389 if (obj1) {
13390 {
13391 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13392 if (SWIG_arg_fail(2)) SWIG_fail;
13393 }
13394 }
13395 {
13396 if (!wxPyCheckForApp()) SWIG_fail;
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 result = (bool)((wxSound const *)arg1)->Play(arg2);
13399
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 {
13404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13405 }
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj;
13414 wxString *arg1 = 0 ;
13415 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13416 bool result;
13417 bool temp1 = false ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "filename",(char *) "flags", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13425 {
13426 arg1 = wxString_in_helper(obj0);
13427 if (arg1 == NULL) SWIG_fail;
13428 temp1 = true;
13429 }
13430 if (obj1) {
13431 {
13432 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13433 if (SWIG_arg_fail(2)) SWIG_fail;
13434 }
13435 }
13436 {
13437 if (!wxPyCheckForApp()) SWIG_fail;
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13446 }
13447 {
13448 if (temp1)
13449 delete arg1;
13450 }
13451 return resultobj;
13452 fail:
13453 {
13454 if (temp1)
13455 delete arg1;
13456 }
13457 return NULL;
13458 }
13459
13460
13461 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13462 PyObject *resultobj;
13463 char *kwnames[] = {
13464 NULL
13465 };
13466
13467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13468 {
13469 if (!wxPyCheckForApp()) SWIG_fail;
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 wxSound::Stop();
13472
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 Py_INCREF(Py_None); resultobj = Py_None;
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13484 PyObject *obj;
13485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13486 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13487 Py_INCREF(obj);
13488 return Py_BuildValue((char *)"");
13489 }
13490 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13491 PyObject *resultobj;
13492 wxString *arg1 = 0 ;
13493 wxString *arg2 = 0 ;
13494 wxString *arg3 = 0 ;
13495 wxString *arg4 = 0 ;
13496 wxFileTypeInfo *result;
13497 bool temp1 = false ;
13498 bool temp2 = false ;
13499 bool temp3 = false ;
13500 bool temp4 = false ;
13501 PyObject * obj0 = 0 ;
13502 PyObject * obj1 = 0 ;
13503 PyObject * obj2 = 0 ;
13504 PyObject * obj3 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13510 {
13511 arg1 = wxString_in_helper(obj0);
13512 if (arg1 == NULL) SWIG_fail;
13513 temp1 = true;
13514 }
13515 {
13516 arg2 = wxString_in_helper(obj1);
13517 if (arg2 == NULL) SWIG_fail;
13518 temp2 = true;
13519 }
13520 {
13521 arg3 = wxString_in_helper(obj2);
13522 if (arg3 == NULL) SWIG_fail;
13523 temp3 = true;
13524 }
13525 {
13526 arg4 = wxString_in_helper(obj3);
13527 if (arg4 == NULL) SWIG_fail;
13528 temp4 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13538 {
13539 if (temp1)
13540 delete arg1;
13541 }
13542 {
13543 if (temp2)
13544 delete arg2;
13545 }
13546 {
13547 if (temp3)
13548 delete arg3;
13549 }
13550 {
13551 if (temp4)
13552 delete arg4;
13553 }
13554 return resultobj;
13555 fail:
13556 {
13557 if (temp1)
13558 delete arg1;
13559 }
13560 {
13561 if (temp2)
13562 delete arg2;
13563 }
13564 {
13565 if (temp3)
13566 delete arg3;
13567 }
13568 {
13569 if (temp4)
13570 delete arg4;
13571 }
13572 return NULL;
13573 }
13574
13575
13576 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13577 PyObject *resultobj;
13578 wxArrayString *arg1 = 0 ;
13579 wxFileTypeInfo *result;
13580 bool temp1 = false ;
13581 PyObject * obj0 = 0 ;
13582 char *kwnames[] = {
13583 (char *) "sArray", NULL
13584 };
13585
13586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13587 {
13588 if (! PySequence_Check(obj0)) {
13589 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13590 SWIG_fail;
13591 }
13592 arg1 = new wxArrayString;
13593 temp1 = true;
13594 int i, len=PySequence_Length(obj0);
13595 for (i=0; i<len; i++) {
13596 PyObject* item = PySequence_GetItem(obj0, i);
13597 #if wxUSE_UNICODE
13598 PyObject* str = PyObject_Unicode(item);
13599 #else
13600 PyObject* str = PyObject_Str(item);
13601 #endif
13602 if (PyErr_Occurred()) SWIG_fail;
13603 arg1->Add(Py2wxString(str));
13604 Py_DECREF(item);
13605 Py_DECREF(str);
13606 }
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13616 {
13617 if (temp1) delete arg1;
13618 }
13619 return resultobj;
13620 fail:
13621 {
13622 if (temp1) delete arg1;
13623 }
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxFileTypeInfo *result;
13631 char *kwnames[] = {
13632 NULL
13633 };
13634
13635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj;
13652 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13653 bool result;
13654 PyObject * obj0 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "self", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13661 if (SWIG_arg_fail(1)) SWIG_fail;
13662 {
13663 PyThreadState* __tstate = wxPyBeginAllowThreads();
13664 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13665
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 {
13670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13671 }
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13681 wxString *arg2 = 0 ;
13682 int arg3 = (int) 0 ;
13683 bool temp2 = false ;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 PyObject * obj2 = 0 ;
13687 char *kwnames[] = {
13688 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13693 if (SWIG_arg_fail(1)) SWIG_fail;
13694 {
13695 arg2 = wxString_in_helper(obj1);
13696 if (arg2 == NULL) SWIG_fail;
13697 temp2 = true;
13698 }
13699 if (obj2) {
13700 {
13701 arg3 = (int)(SWIG_As_int(obj2));
13702 if (SWIG_arg_fail(3)) SWIG_fail;
13703 }
13704 }
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13708
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 Py_INCREF(Py_None); resultobj = Py_None;
13713 {
13714 if (temp2)
13715 delete arg2;
13716 }
13717 return resultobj;
13718 fail:
13719 {
13720 if (temp2)
13721 delete arg2;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13730 wxString *arg2 = 0 ;
13731 bool temp2 = false ;
13732 PyObject * obj0 = 0 ;
13733 PyObject * obj1 = 0 ;
13734 char *kwnames[] = {
13735 (char *) "self",(char *) "shortDesc", NULL
13736 };
13737
13738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13740 if (SWIG_arg_fail(1)) SWIG_fail;
13741 {
13742 arg2 = wxString_in_helper(obj1);
13743 if (arg2 == NULL) SWIG_fail;
13744 temp2 = true;
13745 }
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 (arg1)->SetShortDesc((wxString const &)*arg2);
13749
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 Py_INCREF(Py_None); resultobj = Py_None;
13754 {
13755 if (temp2)
13756 delete arg2;
13757 }
13758 return resultobj;
13759 fail:
13760 {
13761 if (temp2)
13762 delete arg2;
13763 }
13764 return NULL;
13765 }
13766
13767
13768 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj;
13770 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13771 wxString *result;
13772 PyObject * obj0 = 0 ;
13773 char *kwnames[] = {
13774 (char *) "self", NULL
13775 };
13776
13777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13779 if (SWIG_arg_fail(1)) SWIG_fail;
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 {
13783 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13784 result = (wxString *) &_result_ref;
13785 }
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 {
13791 #if wxUSE_UNICODE
13792 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13793 #else
13794 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13795 #endif
13796 }
13797 return resultobj;
13798 fail:
13799 return NULL;
13800 }
13801
13802
13803 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13804 PyObject *resultobj;
13805 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13806 wxString *result;
13807 PyObject * obj0 = 0 ;
13808 char *kwnames[] = {
13809 (char *) "self", NULL
13810 };
13811
13812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13814 if (SWIG_arg_fail(1)) SWIG_fail;
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 {
13818 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13819 result = (wxString *) &_result_ref;
13820 }
13821
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 {
13826 #if wxUSE_UNICODE
13827 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13828 #else
13829 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13830 #endif
13831 }
13832 return resultobj;
13833 fail:
13834 return NULL;
13835 }
13836
13837
13838 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj;
13840 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13841 wxString *result;
13842 PyObject * obj0 = 0 ;
13843 char *kwnames[] = {
13844 (char *) "self", NULL
13845 };
13846
13847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13849 if (SWIG_arg_fail(1)) SWIG_fail;
13850 {
13851 PyThreadState* __tstate = wxPyBeginAllowThreads();
13852 {
13853 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13854 result = (wxString *) &_result_ref;
13855 }
13856
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 {
13861 #if wxUSE_UNICODE
13862 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13863 #else
13864 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13865 #endif
13866 }
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj;
13875 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13876 wxString *result;
13877 PyObject * obj0 = 0 ;
13878 char *kwnames[] = {
13879 (char *) "self", NULL
13880 };
13881
13882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13884 if (SWIG_arg_fail(1)) SWIG_fail;
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 {
13888 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13889 result = (wxString *) &_result_ref;
13890 }
13891
13892 wxPyEndAllowThreads(__tstate);
13893 if (PyErr_Occurred()) SWIG_fail;
13894 }
13895 {
13896 #if wxUSE_UNICODE
13897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13898 #else
13899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13900 #endif
13901 }
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj;
13910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13911 wxString *result;
13912 PyObject * obj0 = 0 ;
13913 char *kwnames[] = {
13914 (char *) "self", NULL
13915 };
13916
13917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13919 if (SWIG_arg_fail(1)) SWIG_fail;
13920 {
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 {
13923 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13924 result = (wxString *) &_result_ref;
13925 }
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 {
13931 #if wxUSE_UNICODE
13932 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13933 #else
13934 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13935 #endif
13936 }
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj;
13945 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13946 wxArrayString *result;
13947 PyObject * obj0 = 0 ;
13948 char *kwnames[] = {
13949 (char *) "self", NULL
13950 };
13951
13952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13954 if (SWIG_arg_fail(1)) SWIG_fail;
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 {
13958 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13959 result = (wxArrayString *) &_result_ref;
13960 }
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 {
13966 resultobj = wxArrayString2PyList_helper(*result);
13967 }
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13977 int result;
13978 PyObject * obj0 = 0 ;
13979 char *kwnames[] = {
13980 (char *) "self", NULL
13981 };
13982
13983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13985 if (SWIG_arg_fail(1)) SWIG_fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13989
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 {
13994 resultobj = SWIG_From_int((int)(result));
13995 }
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj;
14004 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14005 wxString *result;
14006 PyObject * obj0 = 0 ;
14007 char *kwnames[] = {
14008 (char *) "self", NULL
14009 };
14010
14011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14013 if (SWIG_arg_fail(1)) SWIG_fail;
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 {
14017 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14018 result = (wxString *) &_result_ref;
14019 }
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 #if wxUSE_UNICODE
14026 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14027 #else
14028 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14029 #endif
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj;
14039 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14040 int result;
14041 PyObject * obj0 = 0 ;
14042 char *kwnames[] = {
14043 (char *) "self", NULL
14044 };
14045
14046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14048 if (SWIG_arg_fail(1)) SWIG_fail;
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14052
14053 wxPyEndAllowThreads(__tstate);
14054 if (PyErr_Occurred()) SWIG_fail;
14055 }
14056 {
14057 resultobj = SWIG_From_int((int)(result));
14058 }
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14066 PyObject *obj;
14067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14068 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14069 Py_INCREF(obj);
14070 return Py_BuildValue((char *)"");
14071 }
14072 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj;
14074 wxFileTypeInfo *arg1 = 0 ;
14075 wxFileType *result;
14076 PyObject * obj0 = 0 ;
14077 char *kwnames[] = {
14078 (char *) "ftInfo", NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14082 {
14083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14084 if (SWIG_arg_fail(1)) SWIG_fail;
14085 if (arg1 == NULL) {
14086 SWIG_null_ref("wxFileTypeInfo");
14087 }
14088 if (SWIG_arg_fail(1)) SWIG_fail;
14089 }
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14093
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxFileType *arg1 = (wxFileType *) 0 ;
14107 PyObject * obj0 = 0 ;
14108 char *kwnames[] = {
14109 (char *) "self", NULL
14110 };
14111
14112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(1)) SWIG_fail;
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 delete arg1;
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxFileType *arg1 = (wxFileType *) 0 ;
14132 PyObject *result;
14133 PyObject * obj0 = 0 ;
14134 char *kwnames[] = {
14135 (char *) "self", NULL
14136 };
14137
14138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14140 if (SWIG_arg_fail(1)) SWIG_fail;
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 result = (PyObject *)wxFileType_GetMimeType(arg1);
14144
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 resultobj = result;
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxFileType *arg1 = (wxFileType *) 0 ;
14158 PyObject *result;
14159 PyObject * obj0 = 0 ;
14160 char *kwnames[] = {
14161 (char *) "self", NULL
14162 };
14163
14164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14166 if (SWIG_arg_fail(1)) SWIG_fail;
14167 {
14168 PyThreadState* __tstate = wxPyBeginAllowThreads();
14169 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14170
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 resultobj = result;
14175 return resultobj;
14176 fail:
14177 return NULL;
14178 }
14179
14180
14181 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14182 PyObject *resultobj;
14183 wxFileType *arg1 = (wxFileType *) 0 ;
14184 PyObject *result;
14185 PyObject * obj0 = 0 ;
14186 char *kwnames[] = {
14187 (char *) "self", NULL
14188 };
14189
14190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14192 if (SWIG_arg_fail(1)) SWIG_fail;
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 result = (PyObject *)wxFileType_GetExtensions(arg1);
14196
14197 wxPyEndAllowThreads(__tstate);
14198 if (PyErr_Occurred()) SWIG_fail;
14199 }
14200 resultobj = result;
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj;
14209 wxFileType *arg1 = (wxFileType *) 0 ;
14210 wxIcon *result;
14211 PyObject * obj0 = 0 ;
14212 char *kwnames[] = {
14213 (char *) "self", NULL
14214 };
14215
14216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14218 if (SWIG_arg_fail(1)) SWIG_fail;
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 result = (wxIcon *)wxFileType_GetIcon(arg1);
14222
14223 wxPyEndAllowThreads(__tstate);
14224 if (PyErr_Occurred()) SWIG_fail;
14225 }
14226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14234 PyObject *resultobj;
14235 wxFileType *arg1 = (wxFileType *) 0 ;
14236 PyObject *result;
14237 PyObject * obj0 = 0 ;
14238 char *kwnames[] = {
14239 (char *) "self", NULL
14240 };
14241
14242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14244 if (SWIG_arg_fail(1)) SWIG_fail;
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14248
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 resultobj = result;
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj;
14261 wxFileType *arg1 = (wxFileType *) 0 ;
14262 PyObject *result;
14263 PyObject * obj0 = 0 ;
14264 char *kwnames[] = {
14265 (char *) "self", NULL
14266 };
14267
14268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14270 if (SWIG_arg_fail(1)) SWIG_fail;
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (PyObject *)wxFileType_GetDescription(arg1);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 resultobj = result;
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj;
14287 wxFileType *arg1 = (wxFileType *) 0 ;
14288 wxString *arg2 = 0 ;
14289 wxString const &arg3_defvalue = wxPyEmptyString ;
14290 wxString *arg3 = (wxString *) &arg3_defvalue ;
14291 PyObject *result;
14292 bool temp2 = false ;
14293 bool temp3 = false ;
14294 PyObject * obj0 = 0 ;
14295 PyObject * obj1 = 0 ;
14296 PyObject * obj2 = 0 ;
14297 char *kwnames[] = {
14298 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14299 };
14300
14301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14303 if (SWIG_arg_fail(1)) SWIG_fail;
14304 {
14305 arg2 = wxString_in_helper(obj1);
14306 if (arg2 == NULL) SWIG_fail;
14307 temp2 = true;
14308 }
14309 if (obj2) {
14310 {
14311 arg3 = wxString_in_helper(obj2);
14312 if (arg3 == NULL) SWIG_fail;
14313 temp3 = true;
14314 }
14315 }
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14319
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 resultobj = result;
14324 {
14325 if (temp2)
14326 delete arg2;
14327 }
14328 {
14329 if (temp3)
14330 delete arg3;
14331 }
14332 return resultobj;
14333 fail:
14334 {
14335 if (temp2)
14336 delete arg2;
14337 }
14338 {
14339 if (temp3)
14340 delete arg3;
14341 }
14342 return NULL;
14343 }
14344
14345
14346 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxFileType *arg1 = (wxFileType *) 0 ;
14349 wxString *arg2 = 0 ;
14350 wxString const &arg3_defvalue = wxPyEmptyString ;
14351 wxString *arg3 = (wxString *) &arg3_defvalue ;
14352 PyObject *result;
14353 bool temp2 = false ;
14354 bool temp3 = false ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 PyObject * obj2 = 0 ;
14358 char *kwnames[] = {
14359 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14360 };
14361
14362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 {
14366 arg2 = wxString_in_helper(obj1);
14367 if (arg2 == NULL) SWIG_fail;
14368 temp2 = true;
14369 }
14370 if (obj2) {
14371 {
14372 arg3 = wxString_in_helper(obj2);
14373 if (arg3 == NULL) SWIG_fail;
14374 temp3 = true;
14375 }
14376 }
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14380
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 resultobj = result;
14385 {
14386 if (temp2)
14387 delete arg2;
14388 }
14389 {
14390 if (temp3)
14391 delete arg3;
14392 }
14393 return resultobj;
14394 fail:
14395 {
14396 if (temp2)
14397 delete arg2;
14398 }
14399 {
14400 if (temp3)
14401 delete arg3;
14402 }
14403 return NULL;
14404 }
14405
14406
14407 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14408 PyObject *resultobj;
14409 wxFileType *arg1 = (wxFileType *) 0 ;
14410 wxString *arg2 = 0 ;
14411 wxString const &arg3_defvalue = wxPyEmptyString ;
14412 wxString *arg3 = (wxString *) &arg3_defvalue ;
14413 PyObject *result;
14414 bool temp2 = false ;
14415 bool temp3 = false ;
14416 PyObject * obj0 = 0 ;
14417 PyObject * obj1 = 0 ;
14418 PyObject * obj2 = 0 ;
14419 char *kwnames[] = {
14420 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14425 if (SWIG_arg_fail(1)) SWIG_fail;
14426 {
14427 arg2 = wxString_in_helper(obj1);
14428 if (arg2 == NULL) SWIG_fail;
14429 temp2 = true;
14430 }
14431 if (obj2) {
14432 {
14433 arg3 = wxString_in_helper(obj2);
14434 if (arg3 == NULL) SWIG_fail;
14435 temp3 = true;
14436 }
14437 }
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14441
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 resultobj = result;
14446 {
14447 if (temp2)
14448 delete arg2;
14449 }
14450 {
14451 if (temp3)
14452 delete arg3;
14453 }
14454 return resultobj;
14455 fail:
14456 {
14457 if (temp2)
14458 delete arg2;
14459 }
14460 {
14461 if (temp3)
14462 delete arg3;
14463 }
14464 return NULL;
14465 }
14466
14467
14468 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14469 PyObject *resultobj;
14470 wxFileType *arg1 = (wxFileType *) 0 ;
14471 wxString *arg2 = 0 ;
14472 wxString *arg3 = 0 ;
14473 bool arg4 = (bool) true ;
14474 bool result;
14475 bool temp2 = false ;
14476 bool temp3 = false ;
14477 PyObject * obj0 = 0 ;
14478 PyObject * obj1 = 0 ;
14479 PyObject * obj2 = 0 ;
14480 PyObject * obj3 = 0 ;
14481 char *kwnames[] = {
14482 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14483 };
14484
14485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(1)) SWIG_fail;
14488 {
14489 arg2 = wxString_in_helper(obj1);
14490 if (arg2 == NULL) SWIG_fail;
14491 temp2 = true;
14492 }
14493 {
14494 arg3 = wxString_in_helper(obj2);
14495 if (arg3 == NULL) SWIG_fail;
14496 temp3 = true;
14497 }
14498 if (obj3) {
14499 {
14500 arg4 = (bool)(SWIG_As_bool(obj3));
14501 if (SWIG_arg_fail(4)) SWIG_fail;
14502 }
14503 }
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14507
14508 wxPyEndAllowThreads(__tstate);
14509 if (PyErr_Occurred()) SWIG_fail;
14510 }
14511 {
14512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14513 }
14514 {
14515 if (temp2)
14516 delete arg2;
14517 }
14518 {
14519 if (temp3)
14520 delete arg3;
14521 }
14522 return resultobj;
14523 fail:
14524 {
14525 if (temp2)
14526 delete arg2;
14527 }
14528 {
14529 if (temp3)
14530 delete arg3;
14531 }
14532 return NULL;
14533 }
14534
14535
14536 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj;
14538 wxFileType *arg1 = (wxFileType *) 0 ;
14539 wxString const &arg2_defvalue = wxPyEmptyString ;
14540 wxString *arg2 = (wxString *) &arg2_defvalue ;
14541 int arg3 = (int) 0 ;
14542 bool result;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char *kwnames[] = {
14548 (char *) "self",(char *) "cmd",(char *) "index", NULL
14549 };
14550
14551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14553 if (SWIG_arg_fail(1)) SWIG_fail;
14554 if (obj1) {
14555 {
14556 arg2 = wxString_in_helper(obj1);
14557 if (arg2 == NULL) SWIG_fail;
14558 temp2 = true;
14559 }
14560 }
14561 if (obj2) {
14562 {
14563 arg3 = (int)(SWIG_As_int(obj2));
14564 if (SWIG_arg_fail(3)) SWIG_fail;
14565 }
14566 }
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14576 }
14577 {
14578 if (temp2)
14579 delete arg2;
14580 }
14581 return resultobj;
14582 fail:
14583 {
14584 if (temp2)
14585 delete arg2;
14586 }
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxFileType *arg1 = (wxFileType *) 0 ;
14594 bool result;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (bool)(arg1)->Unassociate();
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 {
14611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14612 }
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxString *arg1 = 0 ;
14622 wxString *arg2 = 0 ;
14623 wxString const &arg3_defvalue = wxPyEmptyString ;
14624 wxString *arg3 = (wxString *) &arg3_defvalue ;
14625 wxString result;
14626 bool temp1 = false ;
14627 bool temp2 = false ;
14628 bool temp3 = false ;
14629 PyObject * obj0 = 0 ;
14630 PyObject * obj1 = 0 ;
14631 PyObject * obj2 = 0 ;
14632 char *kwnames[] = {
14633 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14634 };
14635
14636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14637 {
14638 arg1 = wxString_in_helper(obj0);
14639 if (arg1 == NULL) SWIG_fail;
14640 temp1 = true;
14641 }
14642 {
14643 arg2 = wxString_in_helper(obj1);
14644 if (arg2 == NULL) SWIG_fail;
14645 temp2 = true;
14646 }
14647 if (obj2) {
14648 {
14649 arg3 = wxString_in_helper(obj2);
14650 if (arg3 == NULL) SWIG_fail;
14651 temp3 = true;
14652 }
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 #if wxUSE_UNICODE
14663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14664 #else
14665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14666 #endif
14667 }
14668 {
14669 if (temp1)
14670 delete arg1;
14671 }
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 {
14677 if (temp3)
14678 delete arg3;
14679 }
14680 return resultobj;
14681 fail:
14682 {
14683 if (temp1)
14684 delete arg1;
14685 }
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 {
14691 if (temp3)
14692 delete arg3;
14693 }
14694 return NULL;
14695 }
14696
14697
14698 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14699 PyObject *obj;
14700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14701 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14702 Py_INCREF(obj);
14703 return Py_BuildValue((char *)"");
14704 }
14705 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14706 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14707 return 1;
14708 }
14709
14710
14711 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14712 PyObject *pyobj;
14713
14714 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14715 return pyobj;
14716 }
14717
14718
14719 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14720 PyObject *resultobj;
14721 wxString *arg1 = 0 ;
14722 wxString *arg2 = 0 ;
14723 bool result;
14724 bool temp1 = false ;
14725 bool temp2 = false ;
14726 PyObject * obj0 = 0 ;
14727 PyObject * obj1 = 0 ;
14728 char *kwnames[] = {
14729 (char *) "mimeType",(char *) "wildcard", NULL
14730 };
14731
14732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14733 {
14734 arg1 = wxString_in_helper(obj0);
14735 if (arg1 == NULL) SWIG_fail;
14736 temp1 = true;
14737 }
14738 {
14739 arg2 = wxString_in_helper(obj1);
14740 if (arg2 == NULL) SWIG_fail;
14741 temp2 = true;
14742 }
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14746
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 {
14751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752 }
14753 {
14754 if (temp1)
14755 delete arg1;
14756 }
14757 {
14758 if (temp2)
14759 delete arg2;
14760 }
14761 return resultobj;
14762 fail:
14763 {
14764 if (temp1)
14765 delete arg1;
14766 }
14767 {
14768 if (temp2)
14769 delete arg2;
14770 }
14771 return NULL;
14772 }
14773
14774
14775 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14776 PyObject *resultobj;
14777 wxMimeTypesManager *result;
14778 char *kwnames[] = {
14779 NULL
14780 };
14781
14782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj;
14799 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14800 int arg2 = (int) wxMAILCAP_ALL ;
14801 wxString const &arg3_defvalue = wxPyEmptyString ;
14802 wxString *arg3 = (wxString *) &arg3_defvalue ;
14803 bool temp3 = false ;
14804 PyObject * obj0 = 0 ;
14805 PyObject * obj1 = 0 ;
14806 PyObject * obj2 = 0 ;
14807 char *kwnames[] = {
14808 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14809 };
14810
14811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14813 if (SWIG_arg_fail(1)) SWIG_fail;
14814 if (obj1) {
14815 {
14816 arg2 = (int)(SWIG_As_int(obj1));
14817 if (SWIG_arg_fail(2)) SWIG_fail;
14818 }
14819 }
14820 if (obj2) {
14821 {
14822 arg3 = wxString_in_helper(obj2);
14823 if (arg3 == NULL) SWIG_fail;
14824 temp3 = true;
14825 }
14826 }
14827 {
14828 PyThreadState* __tstate = wxPyBeginAllowThreads();
14829 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14830
14831 wxPyEndAllowThreads(__tstate);
14832 if (PyErr_Occurred()) SWIG_fail;
14833 }
14834 Py_INCREF(Py_None); resultobj = Py_None;
14835 {
14836 if (temp3)
14837 delete arg3;
14838 }
14839 return resultobj;
14840 fail:
14841 {
14842 if (temp3)
14843 delete arg3;
14844 }
14845 return NULL;
14846 }
14847
14848
14849 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14850 PyObject *resultobj;
14851 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14852 PyObject * obj0 = 0 ;
14853 char *kwnames[] = {
14854 (char *) "self", NULL
14855 };
14856
14857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14859 if (SWIG_arg_fail(1)) SWIG_fail;
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 (arg1)->ClearData();
14863
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 Py_INCREF(Py_None); resultobj = Py_None;
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14875 PyObject *resultobj;
14876 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14877 wxString *arg2 = 0 ;
14878 wxFileType *result;
14879 bool temp2 = false ;
14880 PyObject * obj0 = 0 ;
14881 PyObject * obj1 = 0 ;
14882 char *kwnames[] = {
14883 (char *) "self",(char *) "ext", NULL
14884 };
14885
14886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14888 if (SWIG_arg_fail(1)) SWIG_fail;
14889 {
14890 arg2 = wxString_in_helper(obj1);
14891 if (arg2 == NULL) SWIG_fail;
14892 temp2 = true;
14893 }
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14897
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14902 {
14903 if (temp2)
14904 delete arg2;
14905 }
14906 return resultobj;
14907 fail:
14908 {
14909 if (temp2)
14910 delete arg2;
14911 }
14912 return NULL;
14913 }
14914
14915
14916 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14917 PyObject *resultobj;
14918 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14919 wxString *arg2 = 0 ;
14920 wxFileType *result;
14921 bool temp2 = false ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 char *kwnames[] = {
14925 (char *) "self",(char *) "mimeType", NULL
14926 };
14927
14928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14930 if (SWIG_arg_fail(1)) SWIG_fail;
14931 {
14932 arg2 = wxString_in_helper(obj1);
14933 if (arg2 == NULL) SWIG_fail;
14934 temp2 = true;
14935 }
14936 {
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14939
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14944 {
14945 if (temp2)
14946 delete arg2;
14947 }
14948 return resultobj;
14949 fail:
14950 {
14951 if (temp2)
14952 delete arg2;
14953 }
14954 return NULL;
14955 }
14956
14957
14958 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj;
14960 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14961 wxString *arg2 = 0 ;
14962 bool arg3 = (bool) false ;
14963 bool result;
14964 bool temp2 = false ;
14965 PyObject * obj0 = 0 ;
14966 PyObject * obj1 = 0 ;
14967 PyObject * obj2 = 0 ;
14968 char *kwnames[] = {
14969 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14970 };
14971
14972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 {
14976 arg2 = wxString_in_helper(obj1);
14977 if (arg2 == NULL) SWIG_fail;
14978 temp2 = true;
14979 }
14980 if (obj2) {
14981 {
14982 arg3 = (bool)(SWIG_As_bool(obj2));
14983 if (SWIG_arg_fail(3)) SWIG_fail;
14984 }
14985 }
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14989
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 {
14994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14995 }
14996 {
14997 if (temp2)
14998 delete arg2;
14999 }
15000 return resultobj;
15001 fail:
15002 {
15003 if (temp2)
15004 delete arg2;
15005 }
15006 return NULL;
15007 }
15008
15009
15010 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15011 PyObject *resultobj;
15012 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15013 wxString *arg2 = 0 ;
15014 bool result;
15015 bool temp2 = false ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 char *kwnames[] = {
15019 (char *) "self",(char *) "filename", NULL
15020 };
15021
15022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
15027 if (arg2 == NULL) SWIG_fail;
15028 temp2 = true;
15029 }
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15033
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 {
15038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15039 }
15040 {
15041 if (temp2)
15042 delete arg2;
15043 }
15044 return resultobj;
15045 fail:
15046 {
15047 if (temp2)
15048 delete arg2;
15049 }
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15057 PyObject *result;
15058 PyObject * obj0 = 0 ;
15059 char *kwnames[] = {
15060 (char *) "self", NULL
15061 };
15062
15063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15065 if (SWIG_arg_fail(1)) SWIG_fail;
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15069
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 resultobj = result;
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15083 wxFileTypeInfo *arg2 = 0 ;
15084 PyObject * obj0 = 0 ;
15085 PyObject * obj1 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self",(char *) "ft", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(2)) SWIG_fail;
15096 if (arg2 == NULL) {
15097 SWIG_null_ref("wxFileTypeInfo");
15098 }
15099 if (SWIG_arg_fail(2)) SWIG_fail;
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15104
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 Py_INCREF(Py_None); resultobj = Py_None;
15109 return resultobj;
15110 fail:
15111 return NULL;
15112 }
15113
15114
15115 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15116 PyObject *resultobj;
15117 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15118 wxFileTypeInfo *arg2 = 0 ;
15119 wxFileType *result;
15120 PyObject * obj0 = 0 ;
15121 PyObject * obj1 = 0 ;
15122 char *kwnames[] = {
15123 (char *) "self",(char *) "ftInfo", NULL
15124 };
15125
15126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15128 if (SWIG_arg_fail(1)) SWIG_fail;
15129 {
15130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(2)) SWIG_fail;
15132 if (arg2 == NULL) {
15133 SWIG_null_ref("wxFileTypeInfo");
15134 }
15135 if (SWIG_arg_fail(2)) SWIG_fail;
15136 }
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15145 return resultobj;
15146 fail:
15147 return NULL;
15148 }
15149
15150
15151 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15152 PyObject *resultobj;
15153 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15154 wxFileType *arg2 = (wxFileType *) 0 ;
15155 bool result;
15156 PyObject * obj0 = 0 ;
15157 PyObject * obj1 = 0 ;
15158 char *kwnames[] = {
15159 (char *) "self",(char *) "ft", NULL
15160 };
15161
15162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15164 if (SWIG_arg_fail(1)) SWIG_fail;
15165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15166 if (SWIG_arg_fail(2)) SWIG_fail;
15167 {
15168 PyThreadState* __tstate = wxPyBeginAllowThreads();
15169 result = (bool)(arg1)->Unassociate(arg2);
15170
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 {
15175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15176 }
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj;
15185 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15186 PyObject * obj0 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 delete arg1;
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 Py_INCREF(Py_None); resultobj = Py_None;
15202 return resultobj;
15203 fail:
15204 return NULL;
15205 }
15206
15207
15208 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15209 PyObject *obj;
15210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15211 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15212 Py_INCREF(obj);
15213 return Py_BuildValue((char *)"");
15214 }
15215 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15216 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15217 return 1;
15218 }
15219
15220
15221 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15222 PyObject *pyobj;
15223
15224 {
15225 #if wxUSE_UNICODE
15226 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15227 #else
15228 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15229 #endif
15230 }
15231 return pyobj;
15232 }
15233
15234
15235 static int _wrap_ART_MENU_set(PyObject *) {
15236 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15237 return 1;
15238 }
15239
15240
15241 static PyObject *_wrap_ART_MENU_get(void) {
15242 PyObject *pyobj;
15243
15244 {
15245 #if wxUSE_UNICODE
15246 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15247 #else
15248 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15249 #endif
15250 }
15251 return pyobj;
15252 }
15253
15254
15255 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15256 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15257 return 1;
15258 }
15259
15260
15261 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15262 PyObject *pyobj;
15263
15264 {
15265 #if wxUSE_UNICODE
15266 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15267 #else
15268 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15269 #endif
15270 }
15271 return pyobj;
15272 }
15273
15274
15275 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15276 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15277 return 1;
15278 }
15279
15280
15281 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15282 PyObject *pyobj;
15283
15284 {
15285 #if wxUSE_UNICODE
15286 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15287 #else
15288 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15289 #endif
15290 }
15291 return pyobj;
15292 }
15293
15294
15295 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15296 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15297 return 1;
15298 }
15299
15300
15301 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15302 PyObject *pyobj;
15303
15304 {
15305 #if wxUSE_UNICODE
15306 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15307 #else
15308 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15309 #endif
15310 }
15311 return pyobj;
15312 }
15313
15314
15315 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15316 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15317 return 1;
15318 }
15319
15320
15321 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15322 PyObject *pyobj;
15323
15324 {
15325 #if wxUSE_UNICODE
15326 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15327 #else
15328 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15329 #endif
15330 }
15331 return pyobj;
15332 }
15333
15334
15335 static int _wrap_ART_BUTTON_set(PyObject *) {
15336 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15337 return 1;
15338 }
15339
15340
15341 static PyObject *_wrap_ART_BUTTON_get(void) {
15342 PyObject *pyobj;
15343
15344 {
15345 #if wxUSE_UNICODE
15346 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15347 #else
15348 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15349 #endif
15350 }
15351 return pyobj;
15352 }
15353
15354
15355 static int _wrap_ART_OTHER_set(PyObject *) {
15356 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15357 return 1;
15358 }
15359
15360
15361 static PyObject *_wrap_ART_OTHER_get(void) {
15362 PyObject *pyobj;
15363
15364 {
15365 #if wxUSE_UNICODE
15366 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15367 #else
15368 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15369 #endif
15370 }
15371 return pyobj;
15372 }
15373
15374
15375 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15376 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15377 return 1;
15378 }
15379
15380
15381 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15382 PyObject *pyobj;
15383
15384 {
15385 #if wxUSE_UNICODE
15386 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15387 #else
15388 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15389 #endif
15390 }
15391 return pyobj;
15392 }
15393
15394
15395 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15396 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15397 return 1;
15398 }
15399
15400
15401 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15402 PyObject *pyobj;
15403
15404 {
15405 #if wxUSE_UNICODE
15406 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15407 #else
15408 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15409 #endif
15410 }
15411 return pyobj;
15412 }
15413
15414
15415 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15416 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15417 return 1;
15418 }
15419
15420
15421 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15422 PyObject *pyobj;
15423
15424 {
15425 #if wxUSE_UNICODE
15426 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15427 #else
15428 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15429 #endif
15430 }
15431 return pyobj;
15432 }
15433
15434
15435 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15436 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15437 return 1;
15438 }
15439
15440
15441 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15442 PyObject *pyobj;
15443
15444 {
15445 #if wxUSE_UNICODE
15446 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15447 #else
15448 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15449 #endif
15450 }
15451 return pyobj;
15452 }
15453
15454
15455 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15456 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15457 return 1;
15458 }
15459
15460
15461 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15462 PyObject *pyobj;
15463
15464 {
15465 #if wxUSE_UNICODE
15466 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15467 #else
15468 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15469 #endif
15470 }
15471 return pyobj;
15472 }
15473
15474
15475 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15476 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15477 return 1;
15478 }
15479
15480
15481 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15482 PyObject *pyobj;
15483
15484 {
15485 #if wxUSE_UNICODE
15486 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15487 #else
15488 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15489 #endif
15490 }
15491 return pyobj;
15492 }
15493
15494
15495 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15496 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15497 return 1;
15498 }
15499
15500
15501 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15502 PyObject *pyobj;
15503
15504 {
15505 #if wxUSE_UNICODE
15506 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15507 #else
15508 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15509 #endif
15510 }
15511 return pyobj;
15512 }
15513
15514
15515 static int _wrap_ART_GO_BACK_set(PyObject *) {
15516 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15517 return 1;
15518 }
15519
15520
15521 static PyObject *_wrap_ART_GO_BACK_get(void) {
15522 PyObject *pyobj;
15523
15524 {
15525 #if wxUSE_UNICODE
15526 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15527 #else
15528 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15529 #endif
15530 }
15531 return pyobj;
15532 }
15533
15534
15535 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15536 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15537 return 1;
15538 }
15539
15540
15541 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15542 PyObject *pyobj;
15543
15544 {
15545 #if wxUSE_UNICODE
15546 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15547 #else
15548 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15549 #endif
15550 }
15551 return pyobj;
15552 }
15553
15554
15555 static int _wrap_ART_GO_UP_set(PyObject *) {
15556 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15557 return 1;
15558 }
15559
15560
15561 static PyObject *_wrap_ART_GO_UP_get(void) {
15562 PyObject *pyobj;
15563
15564 {
15565 #if wxUSE_UNICODE
15566 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15567 #else
15568 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15569 #endif
15570 }
15571 return pyobj;
15572 }
15573
15574
15575 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15576 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15577 return 1;
15578 }
15579
15580
15581 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15582 PyObject *pyobj;
15583
15584 {
15585 #if wxUSE_UNICODE
15586 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15587 #else
15588 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15589 #endif
15590 }
15591 return pyobj;
15592 }
15593
15594
15595 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15596 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15597 return 1;
15598 }
15599
15600
15601 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15602 PyObject *pyobj;
15603
15604 {
15605 #if wxUSE_UNICODE
15606 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15607 #else
15608 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15609 #endif
15610 }
15611 return pyobj;
15612 }
15613
15614
15615 static int _wrap_ART_GO_HOME_set(PyObject *) {
15616 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15617 return 1;
15618 }
15619
15620
15621 static PyObject *_wrap_ART_GO_HOME_get(void) {
15622 PyObject *pyobj;
15623
15624 {
15625 #if wxUSE_UNICODE
15626 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15627 #else
15628 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15629 #endif
15630 }
15631 return pyobj;
15632 }
15633
15634
15635 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15636 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15637 return 1;
15638 }
15639
15640
15641 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15642 PyObject *pyobj;
15643
15644 {
15645 #if wxUSE_UNICODE
15646 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15647 #else
15648 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15649 #endif
15650 }
15651 return pyobj;
15652 }
15653
15654
15655 static int _wrap_ART_PRINT_set(PyObject *) {
15656 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15657 return 1;
15658 }
15659
15660
15661 static PyObject *_wrap_ART_PRINT_get(void) {
15662 PyObject *pyobj;
15663
15664 {
15665 #if wxUSE_UNICODE
15666 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15667 #else
15668 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15669 #endif
15670 }
15671 return pyobj;
15672 }
15673
15674
15675 static int _wrap_ART_HELP_set(PyObject *) {
15676 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15677 return 1;
15678 }
15679
15680
15681 static PyObject *_wrap_ART_HELP_get(void) {
15682 PyObject *pyobj;
15683
15684 {
15685 #if wxUSE_UNICODE
15686 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15687 #else
15688 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15689 #endif
15690 }
15691 return pyobj;
15692 }
15693
15694
15695 static int _wrap_ART_TIP_set(PyObject *) {
15696 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15697 return 1;
15698 }
15699
15700
15701 static PyObject *_wrap_ART_TIP_get(void) {
15702 PyObject *pyobj;
15703
15704 {
15705 #if wxUSE_UNICODE
15706 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15707 #else
15708 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15709 #endif
15710 }
15711 return pyobj;
15712 }
15713
15714
15715 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15716 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15717 return 1;
15718 }
15719
15720
15721 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15722 PyObject *pyobj;
15723
15724 {
15725 #if wxUSE_UNICODE
15726 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15727 #else
15728 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15729 #endif
15730 }
15731 return pyobj;
15732 }
15733
15734
15735 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15736 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15737 return 1;
15738 }
15739
15740
15741 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15742 PyObject *pyobj;
15743
15744 {
15745 #if wxUSE_UNICODE
15746 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15747 #else
15748 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15749 #endif
15750 }
15751 return pyobj;
15752 }
15753
15754
15755 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15756 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15757 return 1;
15758 }
15759
15760
15761 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15762 PyObject *pyobj;
15763
15764 {
15765 #if wxUSE_UNICODE
15766 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15767 #else
15768 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15769 #endif
15770 }
15771 return pyobj;
15772 }
15773
15774
15775 static int _wrap_ART_HARDDISK_set(PyObject *) {
15776 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15777 return 1;
15778 }
15779
15780
15781 static PyObject *_wrap_ART_HARDDISK_get(void) {
15782 PyObject *pyobj;
15783
15784 {
15785 #if wxUSE_UNICODE
15786 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15787 #else
15788 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15789 #endif
15790 }
15791 return pyobj;
15792 }
15793
15794
15795 static int _wrap_ART_FLOPPY_set(PyObject *) {
15796 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15797 return 1;
15798 }
15799
15800
15801 static PyObject *_wrap_ART_FLOPPY_get(void) {
15802 PyObject *pyobj;
15803
15804 {
15805 #if wxUSE_UNICODE
15806 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15807 #else
15808 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15809 #endif
15810 }
15811 return pyobj;
15812 }
15813
15814
15815 static int _wrap_ART_CDROM_set(PyObject *) {
15816 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15817 return 1;
15818 }
15819
15820
15821 static PyObject *_wrap_ART_CDROM_get(void) {
15822 PyObject *pyobj;
15823
15824 {
15825 #if wxUSE_UNICODE
15826 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15827 #else
15828 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15829 #endif
15830 }
15831 return pyobj;
15832 }
15833
15834
15835 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15836 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15837 return 1;
15838 }
15839
15840
15841 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15842 PyObject *pyobj;
15843
15844 {
15845 #if wxUSE_UNICODE
15846 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15847 #else
15848 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15849 #endif
15850 }
15851 return pyobj;
15852 }
15853
15854
15855 static int _wrap_ART_FOLDER_set(PyObject *) {
15856 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15857 return 1;
15858 }
15859
15860
15861 static PyObject *_wrap_ART_FOLDER_get(void) {
15862 PyObject *pyobj;
15863
15864 {
15865 #if wxUSE_UNICODE
15866 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15867 #else
15868 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15869 #endif
15870 }
15871 return pyobj;
15872 }
15873
15874
15875 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15876 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15877 return 1;
15878 }
15879
15880
15881 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15882 PyObject *pyobj;
15883
15884 {
15885 #if wxUSE_UNICODE
15886 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15887 #else
15888 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15889 #endif
15890 }
15891 return pyobj;
15892 }
15893
15894
15895 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15896 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15897 return 1;
15898 }
15899
15900
15901 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15902 PyObject *pyobj;
15903
15904 {
15905 #if wxUSE_UNICODE
15906 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15907 #else
15908 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15909 #endif
15910 }
15911 return pyobj;
15912 }
15913
15914
15915 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15916 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15917 return 1;
15918 }
15919
15920
15921 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15922 PyObject *pyobj;
15923
15924 {
15925 #if wxUSE_UNICODE
15926 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15927 #else
15928 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15929 #endif
15930 }
15931 return pyobj;
15932 }
15933
15934
15935 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15936 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15937 return 1;
15938 }
15939
15940
15941 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15942 PyObject *pyobj;
15943
15944 {
15945 #if wxUSE_UNICODE
15946 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15947 #else
15948 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15949 #endif
15950 }
15951 return pyobj;
15952 }
15953
15954
15955 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15956 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15957 return 1;
15958 }
15959
15960
15961 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15962 PyObject *pyobj;
15963
15964 {
15965 #if wxUSE_UNICODE
15966 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15967 #else
15968 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15969 #endif
15970 }
15971 return pyobj;
15972 }
15973
15974
15975 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15976 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15977 return 1;
15978 }
15979
15980
15981 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15982 PyObject *pyobj;
15983
15984 {
15985 #if wxUSE_UNICODE
15986 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15987 #else
15988 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15989 #endif
15990 }
15991 return pyobj;
15992 }
15993
15994
15995 static int _wrap_ART_ERROR_set(PyObject *) {
15996 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
15997 return 1;
15998 }
15999
16000
16001 static PyObject *_wrap_ART_ERROR_get(void) {
16002 PyObject *pyobj;
16003
16004 {
16005 #if wxUSE_UNICODE
16006 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16007 #else
16008 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16009 #endif
16010 }
16011 return pyobj;
16012 }
16013
16014
16015 static int _wrap_ART_QUESTION_set(PyObject *) {
16016 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16017 return 1;
16018 }
16019
16020
16021 static PyObject *_wrap_ART_QUESTION_get(void) {
16022 PyObject *pyobj;
16023
16024 {
16025 #if wxUSE_UNICODE
16026 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16027 #else
16028 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16029 #endif
16030 }
16031 return pyobj;
16032 }
16033
16034
16035 static int _wrap_ART_WARNING_set(PyObject *) {
16036 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16037 return 1;
16038 }
16039
16040
16041 static PyObject *_wrap_ART_WARNING_get(void) {
16042 PyObject *pyobj;
16043
16044 {
16045 #if wxUSE_UNICODE
16046 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16047 #else
16048 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16049 #endif
16050 }
16051 return pyobj;
16052 }
16053
16054
16055 static int _wrap_ART_INFORMATION_set(PyObject *) {
16056 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16057 return 1;
16058 }
16059
16060
16061 static PyObject *_wrap_ART_INFORMATION_get(void) {
16062 PyObject *pyobj;
16063
16064 {
16065 #if wxUSE_UNICODE
16066 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16067 #else
16068 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16069 #endif
16070 }
16071 return pyobj;
16072 }
16073
16074
16075 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16076 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16077 return 1;
16078 }
16079
16080
16081 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16082 PyObject *pyobj;
16083
16084 {
16085 #if wxUSE_UNICODE
16086 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16087 #else
16088 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16089 #endif
16090 }
16091 return pyobj;
16092 }
16093
16094
16095 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj;
16097 wxPyArtProvider *result;
16098 char *kwnames[] = {
16099 NULL
16100 };
16101
16102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16103 {
16104 if (!wxPyCheckForApp()) SWIG_fail;
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (wxPyArtProvider *)new wxPyArtProvider();
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16121 PyObject *arg2 = (PyObject *) 0 ;
16122 PyObject *arg3 = (PyObject *) 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 char *kwnames[] = {
16127 (char *) "self",(char *) "self",(char *) "_class", NULL
16128 };
16129
16130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16132 if (SWIG_arg_fail(1)) SWIG_fail;
16133 arg2 = obj1;
16134 arg3 = obj2;
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 (arg1)->_setCallbackInfo(arg2,arg3);
16138
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 Py_INCREF(Py_None); resultobj = Py_None;
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj;
16151 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16152 PyObject * obj0 = 0 ;
16153 char *kwnames[] = {
16154 (char *) "provider", NULL
16155 };
16156
16157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16159 if (SWIG_arg_fail(1)) SWIG_fail;
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 wxPyArtProvider::PushProvider(arg1);
16163
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 Py_INCREF(Py_None); resultobj = Py_None;
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 bool result;
16177 char *kwnames[] = {
16178 NULL
16179 };
16180
16181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 result = (bool)wxPyArtProvider::PopProvider();
16185
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 {
16190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16191 }
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16199 PyObject *resultobj;
16200 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16201 bool result;
16202 PyObject * obj0 = 0 ;
16203 char *kwnames[] = {
16204 (char *) "provider", NULL
16205 };
16206
16207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16209 if (SWIG_arg_fail(1)) SWIG_fail;
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16213
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 {
16218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16219 }
16220 return resultobj;
16221 fail:
16222 return NULL;
16223 }
16224
16225
16226 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16227 PyObject *resultobj;
16228 wxString *arg1 = 0 ;
16229 wxString const &arg2_defvalue = wxPyART_OTHER ;
16230 wxString *arg2 = (wxString *) &arg2_defvalue ;
16231 wxSize const &arg3_defvalue = wxDefaultSize ;
16232 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16233 wxBitmap result;
16234 bool temp1 = false ;
16235 bool temp2 = false ;
16236 wxSize temp3 ;
16237 PyObject * obj0 = 0 ;
16238 PyObject * obj1 = 0 ;
16239 PyObject * obj2 = 0 ;
16240 char *kwnames[] = {
16241 (char *) "id",(char *) "client",(char *) "size", NULL
16242 };
16243
16244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16245 {
16246 arg1 = wxString_in_helper(obj0);
16247 if (arg1 == NULL) SWIG_fail;
16248 temp1 = true;
16249 }
16250 if (obj1) {
16251 {
16252 arg2 = wxString_in_helper(obj1);
16253 if (arg2 == NULL) SWIG_fail;
16254 temp2 = true;
16255 }
16256 }
16257 if (obj2) {
16258 {
16259 arg3 = &temp3;
16260 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16261 }
16262 }
16263 {
16264 if (!wxPyCheckForApp()) SWIG_fail;
16265 PyThreadState* __tstate = wxPyBeginAllowThreads();
16266 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16267
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 {
16272 wxBitmap * resultptr;
16273 resultptr = new wxBitmap((wxBitmap &)(result));
16274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16275 }
16276 {
16277 if (temp1)
16278 delete arg1;
16279 }
16280 {
16281 if (temp2)
16282 delete arg2;
16283 }
16284 return resultobj;
16285 fail:
16286 {
16287 if (temp1)
16288 delete arg1;
16289 }
16290 {
16291 if (temp2)
16292 delete arg2;
16293 }
16294 return NULL;
16295 }
16296
16297
16298 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16299 PyObject *resultobj;
16300 wxString *arg1 = 0 ;
16301 wxString const &arg2_defvalue = wxPyART_OTHER ;
16302 wxString *arg2 = (wxString *) &arg2_defvalue ;
16303 wxSize const &arg3_defvalue = wxDefaultSize ;
16304 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16305 wxIcon result;
16306 bool temp1 = false ;
16307 bool temp2 = false ;
16308 wxSize temp3 ;
16309 PyObject * obj0 = 0 ;
16310 PyObject * obj1 = 0 ;
16311 PyObject * obj2 = 0 ;
16312 char *kwnames[] = {
16313 (char *) "id",(char *) "client",(char *) "size", NULL
16314 };
16315
16316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16317 {
16318 arg1 = wxString_in_helper(obj0);
16319 if (arg1 == NULL) SWIG_fail;
16320 temp1 = true;
16321 }
16322 if (obj1) {
16323 {
16324 arg2 = wxString_in_helper(obj1);
16325 if (arg2 == NULL) SWIG_fail;
16326 temp2 = true;
16327 }
16328 }
16329 if (obj2) {
16330 {
16331 arg3 = &temp3;
16332 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16333 }
16334 }
16335 {
16336 if (!wxPyCheckForApp()) SWIG_fail;
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16339
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 {
16344 wxIcon * resultptr;
16345 resultptr = new wxIcon((wxIcon &)(result));
16346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16347 }
16348 {
16349 if (temp1)
16350 delete arg1;
16351 }
16352 {
16353 if (temp2)
16354 delete arg2;
16355 }
16356 return resultobj;
16357 fail:
16358 {
16359 if (temp1)
16360 delete arg1;
16361 }
16362 {
16363 if (temp2)
16364 delete arg2;
16365 }
16366 return NULL;
16367 }
16368
16369
16370 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj;
16372 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 wxPyArtProvider_Destroy(arg1);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 Py_INCREF(Py_None); resultobj = Py_None;
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16396 PyObject *obj;
16397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16398 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16399 Py_INCREF(obj);
16400 return Py_BuildValue((char *)"");
16401 }
16402 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj;
16404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16405 PyObject * obj0 = 0 ;
16406 char *kwnames[] = {
16407 (char *) "self", NULL
16408 };
16409
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16412 if (SWIG_arg_fail(1)) SWIG_fail;
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 delete arg1;
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 Py_INCREF(Py_None); resultobj = Py_None;
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj;
16429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16430 wxConfigBase *result;
16431 PyObject * obj0 = 0 ;
16432 char *kwnames[] = {
16433 (char *) "config", NULL
16434 };
16435
16436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16438 if (SWIG_arg_fail(1)) SWIG_fail;
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16442
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj;
16455 bool arg1 = (bool) true ;
16456 wxConfigBase *result;
16457 PyObject * obj0 = 0 ;
16458 char *kwnames[] = {
16459 (char *) "createOnDemand", NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16463 if (obj0) {
16464 {
16465 arg1 = (bool)(SWIG_As_bool(obj0));
16466 if (SWIG_arg_fail(1)) SWIG_fail;
16467 }
16468 }
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16472
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16477 return resultobj;
16478 fail:
16479 return NULL;
16480 }
16481
16482
16483 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16484 PyObject *resultobj;
16485 wxConfigBase *result;
16486 char *kwnames[] = {
16487 NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (wxConfigBase *)wxConfigBase::Create();
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 char *kwnames[] = {
16508 NULL
16509 };
16510
16511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 wxConfigBase::DontCreateOnDemand();
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 Py_INCREF(Py_None); resultobj = Py_None;
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj;
16528 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16529 wxString *arg2 = 0 ;
16530 bool temp2 = false ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 char *kwnames[] = {
16534 (char *) "self",(char *) "path", NULL
16535 };
16536
16537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16539 if (SWIG_arg_fail(1)) SWIG_fail;
16540 {
16541 arg2 = wxString_in_helper(obj1);
16542 if (arg2 == NULL) SWIG_fail;
16543 temp2 = true;
16544 }
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 (arg1)->SetPath((wxString const &)*arg2);
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 Py_INCREF(Py_None); resultobj = Py_None;
16553 {
16554 if (temp2)
16555 delete arg2;
16556 }
16557 return resultobj;
16558 fail:
16559 {
16560 if (temp2)
16561 delete arg2;
16562 }
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16570 wxString *result;
16571 PyObject * obj0 = 0 ;
16572 char *kwnames[] = {
16573 (char *) "self", NULL
16574 };
16575
16576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16578 if (SWIG_arg_fail(1)) SWIG_fail;
16579 {
16580 PyThreadState* __tstate = wxPyBeginAllowThreads();
16581 {
16582 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16583 result = (wxString *) &_result_ref;
16584 }
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 #if wxUSE_UNICODE
16591 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16592 #else
16593 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16594 #endif
16595 }
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16603 PyObject *resultobj;
16604 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16605 PyObject *result;
16606 PyObject * obj0 = 0 ;
16607 char *kwnames[] = {
16608 (char *) "self", NULL
16609 };
16610
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16613 if (SWIG_arg_fail(1)) SWIG_fail;
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16617
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 resultobj = result;
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj;
16630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16631 long arg2 ;
16632 PyObject *result;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char *kwnames[] = {
16636 (char *) "self",(char *) "index", NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16641 if (SWIG_arg_fail(1)) SWIG_fail;
16642 {
16643 arg2 = (long)(SWIG_As_long(obj1));
16644 if (SWIG_arg_fail(2)) SWIG_fail;
16645 }
16646 {
16647 PyThreadState* __tstate = wxPyBeginAllowThreads();
16648 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16649
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 resultobj = result;
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj;
16662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16663 PyObject *result;
16664 PyObject * obj0 = 0 ;
16665 char *kwnames[] = {
16666 (char *) "self", NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16671 if (SWIG_arg_fail(1)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16675
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 resultobj = result;
16680 return resultobj;
16681 fail:
16682 return NULL;
16683 }
16684
16685
16686 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16687 PyObject *resultobj;
16688 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16689 long arg2 ;
16690 PyObject *result;
16691 PyObject * obj0 = 0 ;
16692 PyObject * obj1 = 0 ;
16693 char *kwnames[] = {
16694 (char *) "self",(char *) "index", NULL
16695 };
16696
16697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16699 if (SWIG_arg_fail(1)) SWIG_fail;
16700 {
16701 arg2 = (long)(SWIG_As_long(obj1));
16702 if (SWIG_arg_fail(2)) SWIG_fail;
16703 }
16704 {
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16707
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 resultobj = result;
16712 return resultobj;
16713 fail:
16714 return NULL;
16715 }
16716
16717
16718 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16719 PyObject *resultobj;
16720 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16721 bool arg2 = (bool) false ;
16722 size_t result;
16723 PyObject * obj0 = 0 ;
16724 PyObject * obj1 = 0 ;
16725 char *kwnames[] = {
16726 (char *) "self",(char *) "recursive", NULL
16727 };
16728
16729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16731 if (SWIG_arg_fail(1)) SWIG_fail;
16732 if (obj1) {
16733 {
16734 arg2 = (bool)(SWIG_As_bool(obj1));
16735 if (SWIG_arg_fail(2)) SWIG_fail;
16736 }
16737 }
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16741
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 {
16746 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj;
16756 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16757 bool arg2 = (bool) false ;
16758 size_t result;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self",(char *) "recursive", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 if (obj1) {
16769 {
16770 arg2 = (bool)(SWIG_As_bool(obj1));
16771 if (SWIG_arg_fail(2)) SWIG_fail;
16772 }
16773 }
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16793 wxString *arg2 = 0 ;
16794 bool result;
16795 bool temp2 = false ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 char *kwnames[] = {
16799 (char *) "self",(char *) "name", NULL
16800 };
16801
16802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16804 if (SWIG_arg_fail(1)) SWIG_fail;
16805 {
16806 arg2 = wxString_in_helper(obj1);
16807 if (arg2 == NULL) SWIG_fail;
16808 temp2 = true;
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 {
16818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16819 }
16820 {
16821 if (temp2)
16822 delete arg2;
16823 }
16824 return resultobj;
16825 fail:
16826 {
16827 if (temp2)
16828 delete arg2;
16829 }
16830 return NULL;
16831 }
16832
16833
16834 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16835 PyObject *resultobj;
16836 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16837 wxString *arg2 = 0 ;
16838 bool result;
16839 bool temp2 = false ;
16840 PyObject * obj0 = 0 ;
16841 PyObject * obj1 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self",(char *) "name", NULL
16844 };
16845
16846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16848 if (SWIG_arg_fail(1)) SWIG_fail;
16849 {
16850 arg2 = wxString_in_helper(obj1);
16851 if (arg2 == NULL) SWIG_fail;
16852 temp2 = true;
16853 }
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16857
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 {
16862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16863 }
16864 {
16865 if (temp2)
16866 delete arg2;
16867 }
16868 return resultobj;
16869 fail:
16870 {
16871 if (temp2)
16872 delete arg2;
16873 }
16874 return NULL;
16875 }
16876
16877
16878 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj;
16880 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16881 wxString *arg2 = 0 ;
16882 bool result;
16883 bool temp2 = false ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self",(char *) "name", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16892 if (SWIG_arg_fail(1)) SWIG_fail;
16893 {
16894 arg2 = wxString_in_helper(obj1);
16895 if (arg2 == NULL) SWIG_fail;
16896 temp2 = true;
16897 }
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 {
16909 if (temp2)
16910 delete arg2;
16911 }
16912 return resultobj;
16913 fail:
16914 {
16915 if (temp2)
16916 delete arg2;
16917 }
16918 return NULL;
16919 }
16920
16921
16922 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj;
16924 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16925 wxString *arg2 = 0 ;
16926 wxConfigBase::EntryType result;
16927 bool temp2 = false ;
16928 PyObject * obj0 = 0 ;
16929 PyObject * obj1 = 0 ;
16930 char *kwnames[] = {
16931 (char *) "self",(char *) "name", NULL
16932 };
16933
16934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16936 if (SWIG_arg_fail(1)) SWIG_fail;
16937 {
16938 arg2 = wxString_in_helper(obj1);
16939 if (arg2 == NULL) SWIG_fail;
16940 temp2 = true;
16941 }
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_From_int((result));
16950 {
16951 if (temp2)
16952 delete arg2;
16953 }
16954 return resultobj;
16955 fail:
16956 {
16957 if (temp2)
16958 delete arg2;
16959 }
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj;
16966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16967 wxString *arg2 = 0 ;
16968 wxString const &arg3_defvalue = wxPyEmptyString ;
16969 wxString *arg3 = (wxString *) &arg3_defvalue ;
16970 wxString result;
16971 bool temp2 = false ;
16972 bool temp3 = false ;
16973 PyObject * obj0 = 0 ;
16974 PyObject * obj1 = 0 ;
16975 PyObject * obj2 = 0 ;
16976 char *kwnames[] = {
16977 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16978 };
16979
16980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16982 if (SWIG_arg_fail(1)) SWIG_fail;
16983 {
16984 arg2 = wxString_in_helper(obj1);
16985 if (arg2 == NULL) SWIG_fail;
16986 temp2 = true;
16987 }
16988 if (obj2) {
16989 {
16990 arg3 = wxString_in_helper(obj2);
16991 if (arg3 == NULL) SWIG_fail;
16992 temp3 = true;
16993 }
16994 }
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 {
17003 #if wxUSE_UNICODE
17004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17005 #else
17006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17007 #endif
17008 }
17009 {
17010 if (temp2)
17011 delete arg2;
17012 }
17013 {
17014 if (temp3)
17015 delete arg3;
17016 }
17017 return resultobj;
17018 fail:
17019 {
17020 if (temp2)
17021 delete arg2;
17022 }
17023 {
17024 if (temp3)
17025 delete arg3;
17026 }
17027 return NULL;
17028 }
17029
17030
17031 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj;
17033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17034 wxString *arg2 = 0 ;
17035 long arg3 = (long) 0 ;
17036 long result;
17037 bool temp2 = false ;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 PyObject * obj2 = 0 ;
17041 char *kwnames[] = {
17042 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17043 };
17044
17045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17047 if (SWIG_arg_fail(1)) SWIG_fail;
17048 {
17049 arg2 = wxString_in_helper(obj1);
17050 if (arg2 == NULL) SWIG_fail;
17051 temp2 = true;
17052 }
17053 if (obj2) {
17054 {
17055 arg3 = (long)(SWIG_As_long(obj2));
17056 if (SWIG_arg_fail(3)) SWIG_fail;
17057 }
17058 }
17059 {
17060 PyThreadState* __tstate = wxPyBeginAllowThreads();
17061 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17062
17063 wxPyEndAllowThreads(__tstate);
17064 if (PyErr_Occurred()) SWIG_fail;
17065 }
17066 {
17067 resultobj = SWIG_From_long((long)(result));
17068 }
17069 {
17070 if (temp2)
17071 delete arg2;
17072 }
17073 return resultobj;
17074 fail:
17075 {
17076 if (temp2)
17077 delete arg2;
17078 }
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17086 wxString *arg2 = 0 ;
17087 double arg3 = (double) 0.0 ;
17088 double result;
17089 bool temp2 = false ;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 PyObject * obj2 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 {
17101 arg2 = wxString_in_helper(obj1);
17102 if (arg2 == NULL) SWIG_fail;
17103 temp2 = true;
17104 }
17105 if (obj2) {
17106 {
17107 arg3 = (double)(SWIG_As_double(obj2));
17108 if (SWIG_arg_fail(3)) SWIG_fail;
17109 }
17110 }
17111 {
17112 PyThreadState* __tstate = wxPyBeginAllowThreads();
17113 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17114
17115 wxPyEndAllowThreads(__tstate);
17116 if (PyErr_Occurred()) SWIG_fail;
17117 }
17118 {
17119 resultobj = SWIG_From_double((double)(result));
17120 }
17121 {
17122 if (temp2)
17123 delete arg2;
17124 }
17125 return resultobj;
17126 fail:
17127 {
17128 if (temp2)
17129 delete arg2;
17130 }
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17138 wxString *arg2 = 0 ;
17139 bool arg3 = (bool) false ;
17140 bool result;
17141 bool temp2 = false ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 PyObject * obj2 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 arg2 = wxString_in_helper(obj1);
17154 if (arg2 == NULL) SWIG_fail;
17155 temp2 = true;
17156 }
17157 if (obj2) {
17158 {
17159 arg3 = (bool)(SWIG_As_bool(obj2));
17160 if (SWIG_arg_fail(3)) SWIG_fail;
17161 }
17162 }
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17166
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 {
17171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17172 }
17173 {
17174 if (temp2)
17175 delete arg2;
17176 }
17177 return resultobj;
17178 fail:
17179 {
17180 if (temp2)
17181 delete arg2;
17182 }
17183 return NULL;
17184 }
17185
17186
17187 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj;
17189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17190 wxString *arg2 = 0 ;
17191 wxString *arg3 = 0 ;
17192 bool result;
17193 bool temp2 = false ;
17194 bool temp3 = false ;
17195 PyObject * obj0 = 0 ;
17196 PyObject * obj1 = 0 ;
17197 PyObject * obj2 = 0 ;
17198 char *kwnames[] = {
17199 (char *) "self",(char *) "key",(char *) "value", NULL
17200 };
17201
17202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17204 if (SWIG_arg_fail(1)) SWIG_fail;
17205 {
17206 arg2 = wxString_in_helper(obj1);
17207 if (arg2 == NULL) SWIG_fail;
17208 temp2 = true;
17209 }
17210 {
17211 arg3 = wxString_in_helper(obj2);
17212 if (arg3 == NULL) SWIG_fail;
17213 temp3 = true;
17214 }
17215 {
17216 PyThreadState* __tstate = wxPyBeginAllowThreads();
17217 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17218
17219 wxPyEndAllowThreads(__tstate);
17220 if (PyErr_Occurred()) SWIG_fail;
17221 }
17222 {
17223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17224 }
17225 {
17226 if (temp2)
17227 delete arg2;
17228 }
17229 {
17230 if (temp3)
17231 delete arg3;
17232 }
17233 return resultobj;
17234 fail:
17235 {
17236 if (temp2)
17237 delete arg2;
17238 }
17239 {
17240 if (temp3)
17241 delete arg3;
17242 }
17243 return NULL;
17244 }
17245
17246
17247 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17248 PyObject *resultobj;
17249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17250 wxString *arg2 = 0 ;
17251 long arg3 ;
17252 bool result;
17253 bool temp2 = false ;
17254 PyObject * obj0 = 0 ;
17255 PyObject * obj1 = 0 ;
17256 PyObject * obj2 = 0 ;
17257 char *kwnames[] = {
17258 (char *) "self",(char *) "key",(char *) "value", NULL
17259 };
17260
17261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17263 if (SWIG_arg_fail(1)) SWIG_fail;
17264 {
17265 arg2 = wxString_in_helper(obj1);
17266 if (arg2 == NULL) SWIG_fail;
17267 temp2 = true;
17268 }
17269 {
17270 arg3 = (long)(SWIG_As_long(obj2));
17271 if (SWIG_arg_fail(3)) SWIG_fail;
17272 }
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17276
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 {
17281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17282 }
17283 {
17284 if (temp2)
17285 delete arg2;
17286 }
17287 return resultobj;
17288 fail:
17289 {
17290 if (temp2)
17291 delete arg2;
17292 }
17293 return NULL;
17294 }
17295
17296
17297 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17298 PyObject *resultobj;
17299 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17300 wxString *arg2 = 0 ;
17301 double arg3 ;
17302 bool result;
17303 bool temp2 = false ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 char *kwnames[] = {
17308 (char *) "self",(char *) "key",(char *) "value", NULL
17309 };
17310
17311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17313 if (SWIG_arg_fail(1)) SWIG_fail;
17314 {
17315 arg2 = wxString_in_helper(obj1);
17316 if (arg2 == NULL) SWIG_fail;
17317 temp2 = true;
17318 }
17319 {
17320 arg3 = (double)(SWIG_As_double(obj2));
17321 if (SWIG_arg_fail(3)) SWIG_fail;
17322 }
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17326
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 {
17331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17332 }
17333 {
17334 if (temp2)
17335 delete arg2;
17336 }
17337 return resultobj;
17338 fail:
17339 {
17340 if (temp2)
17341 delete arg2;
17342 }
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj;
17349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17350 wxString *arg2 = 0 ;
17351 bool arg3 ;
17352 bool result;
17353 bool temp2 = false ;
17354 PyObject * obj0 = 0 ;
17355 PyObject * obj1 = 0 ;
17356 PyObject * obj2 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self",(char *) "key",(char *) "value", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 {
17365 arg2 = wxString_in_helper(obj1);
17366 if (arg2 == NULL) SWIG_fail;
17367 temp2 = true;
17368 }
17369 {
17370 arg3 = (bool)(SWIG_As_bool(obj2));
17371 if (SWIG_arg_fail(3)) SWIG_fail;
17372 }
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17376
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 {
17381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17382 }
17383 {
17384 if (temp2)
17385 delete arg2;
17386 }
17387 return resultobj;
17388 fail:
17389 {
17390 if (temp2)
17391 delete arg2;
17392 }
17393 return NULL;
17394 }
17395
17396
17397 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj;
17399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17400 bool arg2 = (bool) false ;
17401 bool result;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 char *kwnames[] = {
17405 (char *) "self",(char *) "currentOnly", NULL
17406 };
17407
17408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17410 if (SWIG_arg_fail(1)) SWIG_fail;
17411 if (obj1) {
17412 {
17413 arg2 = (bool)(SWIG_As_bool(obj1));
17414 if (SWIG_arg_fail(2)) SWIG_fail;
17415 }
17416 }
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 result = (bool)(arg1)->Flush(arg2);
17420
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 {
17425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17426 }
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj;
17435 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17436 wxString *arg2 = 0 ;
17437 wxString *arg3 = 0 ;
17438 bool result;
17439 bool temp2 = false ;
17440 bool temp3 = false ;
17441 PyObject * obj0 = 0 ;
17442 PyObject * obj1 = 0 ;
17443 PyObject * obj2 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 {
17452 arg2 = wxString_in_helper(obj1);
17453 if (arg2 == NULL) SWIG_fail;
17454 temp2 = true;
17455 }
17456 {
17457 arg3 = wxString_in_helper(obj2);
17458 if (arg3 == NULL) SWIG_fail;
17459 temp3 = true;
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17464
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 {
17469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17470 }
17471 {
17472 if (temp2)
17473 delete arg2;
17474 }
17475 {
17476 if (temp3)
17477 delete arg3;
17478 }
17479 return resultobj;
17480 fail:
17481 {
17482 if (temp2)
17483 delete arg2;
17484 }
17485 {
17486 if (temp3)
17487 delete arg3;
17488 }
17489 return NULL;
17490 }
17491
17492
17493 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj;
17495 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17496 wxString *arg2 = 0 ;
17497 wxString *arg3 = 0 ;
17498 bool result;
17499 bool temp2 = false ;
17500 bool temp3 = false ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 {
17512 arg2 = wxString_in_helper(obj1);
17513 if (arg2 == NULL) SWIG_fail;
17514 temp2 = true;
17515 }
17516 {
17517 arg3 = wxString_in_helper(obj2);
17518 if (arg3 == NULL) SWIG_fail;
17519 temp3 = true;
17520 }
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17524
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 {
17529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17530 }
17531 {
17532 if (temp2)
17533 delete arg2;
17534 }
17535 {
17536 if (temp3)
17537 delete arg3;
17538 }
17539 return resultobj;
17540 fail:
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 {
17546 if (temp3)
17547 delete arg3;
17548 }
17549 return NULL;
17550 }
17551
17552
17553 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17554 PyObject *resultobj;
17555 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17556 wxString *arg2 = 0 ;
17557 bool arg3 = (bool) true ;
17558 bool result;
17559 bool temp2 = false ;
17560 PyObject * obj0 = 0 ;
17561 PyObject * obj1 = 0 ;
17562 PyObject * obj2 = 0 ;
17563 char *kwnames[] = {
17564 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17565 };
17566
17567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17569 if (SWIG_arg_fail(1)) SWIG_fail;
17570 {
17571 arg2 = wxString_in_helper(obj1);
17572 if (arg2 == NULL) SWIG_fail;
17573 temp2 = true;
17574 }
17575 if (obj2) {
17576 {
17577 arg3 = (bool)(SWIG_As_bool(obj2));
17578 if (SWIG_arg_fail(3)) SWIG_fail;
17579 }
17580 }
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17584
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17590 }
17591 {
17592 if (temp2)
17593 delete arg2;
17594 }
17595 return resultobj;
17596 fail:
17597 {
17598 if (temp2)
17599 delete arg2;
17600 }
17601 return NULL;
17602 }
17603
17604
17605 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17606 PyObject *resultobj;
17607 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17608 wxString *arg2 = 0 ;
17609 bool result;
17610 bool temp2 = false ;
17611 PyObject * obj0 = 0 ;
17612 PyObject * obj1 = 0 ;
17613 char *kwnames[] = {
17614 (char *) "self",(char *) "key", NULL
17615 };
17616
17617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17619 if (SWIG_arg_fail(1)) SWIG_fail;
17620 {
17621 arg2 = wxString_in_helper(obj1);
17622 if (arg2 == NULL) SWIG_fail;
17623 temp2 = true;
17624 }
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17628
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 {
17633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17634 }
17635 {
17636 if (temp2)
17637 delete arg2;
17638 }
17639 return resultobj;
17640 fail:
17641 {
17642 if (temp2)
17643 delete arg2;
17644 }
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj;
17651 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17652 bool result;
17653 PyObject * obj0 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self", NULL
17656 };
17657
17658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17660 if (SWIG_arg_fail(1)) SWIG_fail;
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (bool)(arg1)->DeleteAll();
17664
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 {
17669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17670 }
17671 return resultobj;
17672 fail:
17673 return NULL;
17674 }
17675
17676
17677 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj;
17679 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17680 bool arg2 = (bool) true ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 char *kwnames[] = {
17684 (char *) "self",(char *) "doIt", NULL
17685 };
17686
17687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17689 if (SWIG_arg_fail(1)) SWIG_fail;
17690 if (obj1) {
17691 {
17692 arg2 = (bool)(SWIG_As_bool(obj1));
17693 if (SWIG_arg_fail(2)) SWIG_fail;
17694 }
17695 }
17696 {
17697 PyThreadState* __tstate = wxPyBeginAllowThreads();
17698 (arg1)->SetExpandEnvVars(arg2);
17699
17700 wxPyEndAllowThreads(__tstate);
17701 if (PyErr_Occurred()) SWIG_fail;
17702 }
17703 Py_INCREF(Py_None); resultobj = Py_None;
17704 return resultobj;
17705 fail:
17706 return NULL;
17707 }
17708
17709
17710 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17711 PyObject *resultobj;
17712 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17713 bool result;
17714 PyObject * obj0 = 0 ;
17715 char *kwnames[] = {
17716 (char *) "self", NULL
17717 };
17718
17719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17721 if (SWIG_arg_fail(1)) SWIG_fail;
17722 {
17723 PyThreadState* __tstate = wxPyBeginAllowThreads();
17724 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17725
17726 wxPyEndAllowThreads(__tstate);
17727 if (PyErr_Occurred()) SWIG_fail;
17728 }
17729 {
17730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17731 }
17732 return resultobj;
17733 fail:
17734 return NULL;
17735 }
17736
17737
17738 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17739 PyObject *resultobj;
17740 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17741 bool arg2 = (bool) true ;
17742 PyObject * obj0 = 0 ;
17743 PyObject * obj1 = 0 ;
17744 char *kwnames[] = {
17745 (char *) "self",(char *) "doIt", NULL
17746 };
17747
17748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17750 if (SWIG_arg_fail(1)) SWIG_fail;
17751 if (obj1) {
17752 {
17753 arg2 = (bool)(SWIG_As_bool(obj1));
17754 if (SWIG_arg_fail(2)) SWIG_fail;
17755 }
17756 }
17757 {
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 (arg1)->SetRecordDefaults(arg2);
17760
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 Py_INCREF(Py_None); resultobj = Py_None;
17765 return resultobj;
17766 fail:
17767 return NULL;
17768 }
17769
17770
17771 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17772 PyObject *resultobj;
17773 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17774 bool result;
17775 PyObject * obj0 = 0 ;
17776 char *kwnames[] = {
17777 (char *) "self", NULL
17778 };
17779
17780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17782 if (SWIG_arg_fail(1)) SWIG_fail;
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17786
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 {
17791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17792 }
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17802 wxString *arg2 = 0 ;
17803 wxString result;
17804 bool temp2 = false ;
17805 PyObject * obj0 = 0 ;
17806 PyObject * obj1 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self",(char *) "str", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 arg2 = wxString_in_helper(obj1);
17816 if (arg2 == NULL) SWIG_fail;
17817 temp2 = true;
17818 }
17819 {
17820 PyThreadState* __tstate = wxPyBeginAllowThreads();
17821 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17822
17823 wxPyEndAllowThreads(__tstate);
17824 if (PyErr_Occurred()) SWIG_fail;
17825 }
17826 {
17827 #if wxUSE_UNICODE
17828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17829 #else
17830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17831 #endif
17832 }
17833 {
17834 if (temp2)
17835 delete arg2;
17836 }
17837 return resultobj;
17838 fail:
17839 {
17840 if (temp2)
17841 delete arg2;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj;
17849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17850 wxString result;
17851 PyObject * obj0 = 0 ;
17852 char *kwnames[] = {
17853 (char *) "self", NULL
17854 };
17855
17856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17858 if (SWIG_arg_fail(1)) SWIG_fail;
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 result = ((wxConfigBase const *)arg1)->GetAppName();
17862
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 #if wxUSE_UNICODE
17868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17869 #else
17870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17871 #endif
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17880 PyObject *resultobj;
17881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17882 wxString result;
17883 PyObject * obj0 = 0 ;
17884 char *kwnames[] = {
17885 (char *) "self", NULL
17886 };
17887
17888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17890 if (SWIG_arg_fail(1)) SWIG_fail;
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = ((wxConfigBase const *)arg1)->GetVendorName();
17894
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 #if wxUSE_UNICODE
17900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17901 #else
17902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17903 #endif
17904 }
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17914 wxString *arg2 = 0 ;
17915 bool temp2 = false ;
17916 PyObject * obj0 = 0 ;
17917 PyObject * obj1 = 0 ;
17918 char *kwnames[] = {
17919 (char *) "self",(char *) "appName", NULL
17920 };
17921
17922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17924 if (SWIG_arg_fail(1)) SWIG_fail;
17925 {
17926 arg2 = wxString_in_helper(obj1);
17927 if (arg2 == NULL) SWIG_fail;
17928 temp2 = true;
17929 }
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 (arg1)->SetAppName((wxString const &)*arg2);
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 Py_INCREF(Py_None); resultobj = Py_None;
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 return resultobj;
17943 fail:
17944 {
17945 if (temp2)
17946 delete arg2;
17947 }
17948 return NULL;
17949 }
17950
17951
17952 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17953 PyObject *resultobj;
17954 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17955 wxString *arg2 = 0 ;
17956 bool temp2 = false ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 char *kwnames[] = {
17960 (char *) "self",(char *) "vendorName", NULL
17961 };
17962
17963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17965 if (SWIG_arg_fail(1)) SWIG_fail;
17966 {
17967 arg2 = wxString_in_helper(obj1);
17968 if (arg2 == NULL) SWIG_fail;
17969 temp2 = true;
17970 }
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 (arg1)->SetVendorName((wxString const &)*arg2);
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 Py_INCREF(Py_None); resultobj = Py_None;
17979 {
17980 if (temp2)
17981 delete arg2;
17982 }
17983 return resultobj;
17984 fail:
17985 {
17986 if (temp2)
17987 delete arg2;
17988 }
17989 return NULL;
17990 }
17991
17992
17993 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj;
17995 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17996 long arg2 ;
17997 PyObject * obj0 = 0 ;
17998 PyObject * obj1 = 0 ;
17999 char *kwnames[] = {
18000 (char *) "self",(char *) "style", NULL
18001 };
18002
18003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18005 if (SWIG_arg_fail(1)) SWIG_fail;
18006 {
18007 arg2 = (long)(SWIG_As_long(obj1));
18008 if (SWIG_arg_fail(2)) SWIG_fail;
18009 }
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 (arg1)->SetStyle(arg2);
18013
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 Py_INCREF(Py_None); resultobj = Py_None;
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18025 PyObject *resultobj;
18026 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18027 long result;
18028 PyObject * obj0 = 0 ;
18029 char *kwnames[] = {
18030 (char *) "self", NULL
18031 };
18032
18033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18035 if (SWIG_arg_fail(1)) SWIG_fail;
18036 {
18037 PyThreadState* __tstate = wxPyBeginAllowThreads();
18038 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18039
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 {
18044 resultobj = SWIG_From_long((long)(result));
18045 }
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18053 PyObject *obj;
18054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18055 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18056 Py_INCREF(obj);
18057 return Py_BuildValue((char *)"");
18058 }
18059 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18060 PyObject *resultobj;
18061 wxString const &arg1_defvalue = wxPyEmptyString ;
18062 wxString *arg1 = (wxString *) &arg1_defvalue ;
18063 wxString const &arg2_defvalue = wxPyEmptyString ;
18064 wxString *arg2 = (wxString *) &arg2_defvalue ;
18065 wxString const &arg3_defvalue = wxPyEmptyString ;
18066 wxString *arg3 = (wxString *) &arg3_defvalue ;
18067 wxString const &arg4_defvalue = wxPyEmptyString ;
18068 wxString *arg4 = (wxString *) &arg4_defvalue ;
18069 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18070 wxConfig *result;
18071 bool temp1 = false ;
18072 bool temp2 = false ;
18073 bool temp3 = false ;
18074 bool temp4 = false ;
18075 PyObject * obj0 = 0 ;
18076 PyObject * obj1 = 0 ;
18077 PyObject * obj2 = 0 ;
18078 PyObject * obj3 = 0 ;
18079 PyObject * obj4 = 0 ;
18080 char *kwnames[] = {
18081 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18082 };
18083
18084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18085 if (obj0) {
18086 {
18087 arg1 = wxString_in_helper(obj0);
18088 if (arg1 == NULL) SWIG_fail;
18089 temp1 = true;
18090 }
18091 }
18092 if (obj1) {
18093 {
18094 arg2 = wxString_in_helper(obj1);
18095 if (arg2 == NULL) SWIG_fail;
18096 temp2 = true;
18097 }
18098 }
18099 if (obj2) {
18100 {
18101 arg3 = wxString_in_helper(obj2);
18102 if (arg3 == NULL) SWIG_fail;
18103 temp3 = true;
18104 }
18105 }
18106 if (obj3) {
18107 {
18108 arg4 = wxString_in_helper(obj3);
18109 if (arg4 == NULL) SWIG_fail;
18110 temp4 = true;
18111 }
18112 }
18113 if (obj4) {
18114 {
18115 arg5 = (long)(SWIG_As_long(obj4));
18116 if (SWIG_arg_fail(5)) SWIG_fail;
18117 }
18118 }
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18127 {
18128 if (temp1)
18129 delete arg1;
18130 }
18131 {
18132 if (temp2)
18133 delete arg2;
18134 }
18135 {
18136 if (temp3)
18137 delete arg3;
18138 }
18139 {
18140 if (temp4)
18141 delete arg4;
18142 }
18143 return resultobj;
18144 fail:
18145 {
18146 if (temp1)
18147 delete arg1;
18148 }
18149 {
18150 if (temp2)
18151 delete arg2;
18152 }
18153 {
18154 if (temp3)
18155 delete arg3;
18156 }
18157 {
18158 if (temp4)
18159 delete arg4;
18160 }
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj;
18167 wxConfig *arg1 = (wxConfig *) 0 ;
18168 PyObject * obj0 = 0 ;
18169 char *kwnames[] = {
18170 (char *) "self", NULL
18171 };
18172
18173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18175 if (SWIG_arg_fail(1)) SWIG_fail;
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 delete arg1;
18179
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 Py_INCREF(Py_None); resultobj = Py_None;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18191 PyObject *obj;
18192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18193 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18194 Py_INCREF(obj);
18195 return Py_BuildValue((char *)"");
18196 }
18197 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj;
18199 wxString const &arg1_defvalue = wxPyEmptyString ;
18200 wxString *arg1 = (wxString *) &arg1_defvalue ;
18201 wxString const &arg2_defvalue = wxPyEmptyString ;
18202 wxString *arg2 = (wxString *) &arg2_defvalue ;
18203 wxString const &arg3_defvalue = wxPyEmptyString ;
18204 wxString *arg3 = (wxString *) &arg3_defvalue ;
18205 wxString const &arg4_defvalue = wxPyEmptyString ;
18206 wxString *arg4 = (wxString *) &arg4_defvalue ;
18207 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18208 wxFileConfig *result;
18209 bool temp1 = false ;
18210 bool temp2 = false ;
18211 bool temp3 = false ;
18212 bool temp4 = false ;
18213 PyObject * obj0 = 0 ;
18214 PyObject * obj1 = 0 ;
18215 PyObject * obj2 = 0 ;
18216 PyObject * obj3 = 0 ;
18217 PyObject * obj4 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18223 if (obj0) {
18224 {
18225 arg1 = wxString_in_helper(obj0);
18226 if (arg1 == NULL) SWIG_fail;
18227 temp1 = true;
18228 }
18229 }
18230 if (obj1) {
18231 {
18232 arg2 = wxString_in_helper(obj1);
18233 if (arg2 == NULL) SWIG_fail;
18234 temp2 = true;
18235 }
18236 }
18237 if (obj2) {
18238 {
18239 arg3 = wxString_in_helper(obj2);
18240 if (arg3 == NULL) SWIG_fail;
18241 temp3 = true;
18242 }
18243 }
18244 if (obj3) {
18245 {
18246 arg4 = wxString_in_helper(obj3);
18247 if (arg4 == NULL) SWIG_fail;
18248 temp4 = true;
18249 }
18250 }
18251 if (obj4) {
18252 {
18253 arg5 = (long)(SWIG_As_long(obj4));
18254 if (SWIG_arg_fail(5)) SWIG_fail;
18255 }
18256 }
18257 {
18258 PyThreadState* __tstate = wxPyBeginAllowThreads();
18259 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18260
18261 wxPyEndAllowThreads(__tstate);
18262 if (PyErr_Occurred()) SWIG_fail;
18263 }
18264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18265 {
18266 if (temp1)
18267 delete arg1;
18268 }
18269 {
18270 if (temp2)
18271 delete arg2;
18272 }
18273 {
18274 if (temp3)
18275 delete arg3;
18276 }
18277 {
18278 if (temp4)
18279 delete arg4;
18280 }
18281 return resultobj;
18282 fail:
18283 {
18284 if (temp1)
18285 delete arg1;
18286 }
18287 {
18288 if (temp2)
18289 delete arg2;
18290 }
18291 {
18292 if (temp3)
18293 delete arg3;
18294 }
18295 {
18296 if (temp4)
18297 delete arg4;
18298 }
18299 return NULL;
18300 }
18301
18302
18303 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj;
18305 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18306 PyObject * obj0 = 0 ;
18307 char *kwnames[] = {
18308 (char *) "self", NULL
18309 };
18310
18311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18313 if (SWIG_arg_fail(1)) SWIG_fail;
18314 {
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 delete arg1;
18317
18318 wxPyEndAllowThreads(__tstate);
18319 if (PyErr_Occurred()) SWIG_fail;
18320 }
18321 Py_INCREF(Py_None); resultobj = Py_None;
18322 return resultobj;
18323 fail:
18324 return NULL;
18325 }
18326
18327
18328 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18329 PyObject *obj;
18330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18331 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18332 Py_INCREF(obj);
18333 return Py_BuildValue((char *)"");
18334 }
18335 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18338 wxString *arg2 = 0 ;
18339 wxConfigPathChanger *result;
18340 bool temp2 = false ;
18341 PyObject * obj0 = 0 ;
18342 PyObject * obj1 = 0 ;
18343 char *kwnames[] = {
18344 (char *) "config",(char *) "entry", NULL
18345 };
18346
18347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18349 if (SWIG_arg_fail(1)) SWIG_fail;
18350 {
18351 arg2 = wxString_in_helper(obj1);
18352 if (arg2 == NULL) SWIG_fail;
18353 temp2 = true;
18354 }
18355 {
18356 PyThreadState* __tstate = wxPyBeginAllowThreads();
18357 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18358
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18363 {
18364 if (temp2)
18365 delete arg2;
18366 }
18367 return resultobj;
18368 fail:
18369 {
18370 if (temp2)
18371 delete arg2;
18372 }
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18380 PyObject * obj0 = 0 ;
18381 char *kwnames[] = {
18382 (char *) "self", NULL
18383 };
18384
18385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18387 if (SWIG_arg_fail(1)) SWIG_fail;
18388 {
18389 PyThreadState* __tstate = wxPyBeginAllowThreads();
18390 delete arg1;
18391
18392 wxPyEndAllowThreads(__tstate);
18393 if (PyErr_Occurred()) SWIG_fail;
18394 }
18395 Py_INCREF(Py_None); resultobj = Py_None;
18396 return resultobj;
18397 fail:
18398 return NULL;
18399 }
18400
18401
18402 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18403 PyObject *resultobj;
18404 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18405 wxString *result;
18406 PyObject * obj0 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 {
18417 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18418 result = (wxString *) &_result_ref;
18419 }
18420
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 {
18425 #if wxUSE_UNICODE
18426 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18427 #else
18428 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18429 #endif
18430 }
18431 return resultobj;
18432 fail:
18433 return NULL;
18434 }
18435
18436
18437 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18438 PyObject *obj;
18439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18440 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18441 Py_INCREF(obj);
18442 return Py_BuildValue((char *)"");
18443 }
18444 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18445 PyObject *resultobj;
18446 wxString *arg1 = 0 ;
18447 wxString result;
18448 bool temp1 = false ;
18449 PyObject * obj0 = 0 ;
18450 char *kwnames[] = {
18451 (char *) "sz", NULL
18452 };
18453
18454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18455 {
18456 arg1 = wxString_in_helper(obj0);
18457 if (arg1 == NULL) SWIG_fail;
18458 temp1 = true;
18459 }
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 result = wxExpandEnvVars((wxString const &)*arg1);
18463
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 {
18468 #if wxUSE_UNICODE
18469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18470 #else
18471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18472 #endif
18473 }
18474 {
18475 if (temp1)
18476 delete arg1;
18477 }
18478 return resultobj;
18479 fail:
18480 {
18481 if (temp1)
18482 delete arg1;
18483 }
18484 return NULL;
18485 }
18486
18487
18488 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18489 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18490 return 1;
18491 }
18492
18493
18494 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18495 PyObject *pyobj;
18496
18497 {
18498 #if wxUSE_UNICODE
18499 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18500 #else
18501 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18502 #endif
18503 }
18504 return pyobj;
18505 }
18506
18507
18508 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18509 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18510 return 1;
18511 }
18512
18513
18514 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18515 PyObject *pyobj;
18516
18517 {
18518 #if wxUSE_UNICODE
18519 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18520 #else
18521 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18522 #endif
18523 }
18524 return pyobj;
18525 }
18526
18527
18528 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj;
18530 wxDateTime::Country arg1 ;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "country", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18537 {
18538 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18539 if (SWIG_arg_fail(1)) SWIG_fail;
18540 }
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18544
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 Py_INCREF(Py_None); resultobj = Py_None;
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxDateTime::Country result;
18558 char *kwnames[] = {
18559 NULL
18560 };
18561
18562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 result = (wxDateTime::Country)wxDateTime::GetCountry();
18566
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 resultobj = SWIG_From_int((result));
18571 return resultobj;
18572 fail:
18573 return NULL;
18574 }
18575
18576
18577 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18578 PyObject *resultobj;
18579 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18580 bool result;
18581 PyObject * obj0 = 0 ;
18582 char *kwnames[] = {
18583 (char *) "country", NULL
18584 };
18585
18586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18587 if (obj0) {
18588 {
18589 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18590 if (SWIG_arg_fail(1)) SWIG_fail;
18591 }
18592 }
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18596
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 {
18601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18602 }
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18612 int result;
18613 PyObject * obj0 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "cal", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18619 if (obj0) {
18620 {
18621 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18622 if (SWIG_arg_fail(1)) SWIG_fail;
18623 }
18624 }
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 {
18633 resultobj = SWIG_From_int((int)(result));
18634 }
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 int arg1 ;
18644 int result;
18645 PyObject * obj0 = 0 ;
18646 char *kwnames[] = {
18647 (char *) "year", NULL
18648 };
18649
18650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18651 {
18652 arg1 = (int)(SWIG_As_int(obj0));
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 }
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 result = (int)wxDateTime::ConvertYearToBC(arg1);
18658
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 {
18663 resultobj = SWIG_From_int((int)(result));
18664 }
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj;
18673 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18674 wxDateTime::Month result;
18675 PyObject * obj0 = 0 ;
18676 char *kwnames[] = {
18677 (char *) "cal", NULL
18678 };
18679
18680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18681 if (obj0) {
18682 {
18683 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18684 if (SWIG_arg_fail(1)) SWIG_fail;
18685 }
18686 }
18687 {
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18690
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 resultobj = SWIG_From_int((result));
18695 return resultobj;
18696 fail:
18697 return NULL;
18698 }
18699
18700
18701 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18702 PyObject *resultobj;
18703 int arg1 = (int) wxDateTime::Inv_Year ;
18704 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18705 bool result;
18706 PyObject * obj0 = 0 ;
18707 PyObject * obj1 = 0 ;
18708 char *kwnames[] = {
18709 (char *) "year",(char *) "cal", NULL
18710 };
18711
18712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18713 if (obj0) {
18714 {
18715 arg1 = (int)(SWIG_As_int(obj0));
18716 if (SWIG_arg_fail(1)) SWIG_fail;
18717 }
18718 }
18719 if (obj1) {
18720 {
18721 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18722 if (SWIG_arg_fail(2)) SWIG_fail;
18723 }
18724 }
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18728
18729 wxPyEndAllowThreads(__tstate);
18730 if (PyErr_Occurred()) SWIG_fail;
18731 }
18732 {
18733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18734 }
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18742 PyObject *resultobj;
18743 int arg1 = (int) wxDateTime::Inv_Year ;
18744 int result;
18745 PyObject * obj0 = 0 ;
18746 char *kwnames[] = {
18747 (char *) "year", NULL
18748 };
18749
18750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18751 if (obj0) {
18752 {
18753 arg1 = (int)(SWIG_As_int(obj0));
18754 if (SWIG_arg_fail(1)) SWIG_fail;
18755 }
18756 }
18757 {
18758 PyThreadState* __tstate = wxPyBeginAllowThreads();
18759 result = (int)wxDateTime::GetCentury(arg1);
18760
18761 wxPyEndAllowThreads(__tstate);
18762 if (PyErr_Occurred()) SWIG_fail;
18763 }
18764 {
18765 resultobj = SWIG_From_int((int)(result));
18766 }
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18774 PyObject *resultobj;
18775 int arg1 ;
18776 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18777 int result;
18778 PyObject * obj0 = 0 ;
18779 PyObject * obj1 = 0 ;
18780 char *kwnames[] = {
18781 (char *) "year",(char *) "cal", NULL
18782 };
18783
18784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18785 {
18786 arg1 = (int)(SWIG_As_int(obj0));
18787 if (SWIG_arg_fail(1)) SWIG_fail;
18788 }
18789 if (obj1) {
18790 {
18791 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18792 if (SWIG_arg_fail(2)) SWIG_fail;
18793 }
18794 }
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18798
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 {
18803 resultobj = SWIG_From_int((int)(result));
18804 }
18805 return resultobj;
18806 fail:
18807 return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxDateTime::Month arg1 ;
18814 int arg2 = (int) wxDateTime::Inv_Year ;
18815 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18816 int result;
18817 PyObject * obj0 = 0 ;
18818 PyObject * obj1 = 0 ;
18819 PyObject * obj2 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "month",(char *) "year",(char *) "cal", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18825 {
18826 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18827 if (SWIG_arg_fail(1)) SWIG_fail;
18828 }
18829 if (obj1) {
18830 {
18831 arg2 = (int)(SWIG_As_int(obj1));
18832 if (SWIG_arg_fail(2)) SWIG_fail;
18833 }
18834 }
18835 if (obj2) {
18836 {
18837 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18838 if (SWIG_arg_fail(3)) SWIG_fail;
18839 }
18840 }
18841 {
18842 PyThreadState* __tstate = wxPyBeginAllowThreads();
18843 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18844
18845 wxPyEndAllowThreads(__tstate);
18846 if (PyErr_Occurred()) SWIG_fail;
18847 }
18848 {
18849 resultobj = SWIG_From_int((int)(result));
18850 }
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj;
18859 wxDateTime::Month arg1 ;
18860 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18861 wxString result;
18862 PyObject * obj0 = 0 ;
18863 PyObject * obj1 = 0 ;
18864 char *kwnames[] = {
18865 (char *) "month",(char *) "flags", NULL
18866 };
18867
18868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18869 {
18870 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18871 if (SWIG_arg_fail(1)) SWIG_fail;
18872 }
18873 if (obj1) {
18874 {
18875 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18876 if (SWIG_arg_fail(2)) SWIG_fail;
18877 }
18878 }
18879 {
18880 PyThreadState* __tstate = wxPyBeginAllowThreads();
18881 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18882
18883 wxPyEndAllowThreads(__tstate);
18884 if (PyErr_Occurred()) SWIG_fail;
18885 }
18886 {
18887 #if wxUSE_UNICODE
18888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18889 #else
18890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18891 #endif
18892 }
18893 return resultobj;
18894 fail:
18895 return NULL;
18896 }
18897
18898
18899 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18900 PyObject *resultobj;
18901 wxDateTime::WeekDay arg1 ;
18902 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18903 wxString result;
18904 PyObject * obj0 = 0 ;
18905 PyObject * obj1 = 0 ;
18906 char *kwnames[] = {
18907 (char *) "weekday",(char *) "flags", NULL
18908 };
18909
18910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18911 {
18912 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18913 if (SWIG_arg_fail(1)) SWIG_fail;
18914 }
18915 if (obj1) {
18916 {
18917 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18918 if (SWIG_arg_fail(2)) SWIG_fail;
18919 }
18920 }
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18924
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 {
18929 #if wxUSE_UNICODE
18930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18931 #else
18932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18933 #endif
18934 }
18935 return resultobj;
18936 fail:
18937 return NULL;
18938 }
18939
18940
18941 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18942 PyObject *resultobj;
18943 wxString *arg1 = (wxString *) 0 ;
18944 wxString *arg2 = (wxString *) 0 ;
18945 bool temp1 = false ;
18946 bool temp2 = false ;
18947 PyObject * obj0 = 0 ;
18948 PyObject * obj1 = 0 ;
18949 char *kwnames[] = {
18950 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18951 };
18952
18953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18954 {
18955 arg1 = wxString_in_helper(obj0);
18956 if (arg1 == NULL) SWIG_fail;
18957 temp1 = true;
18958 }
18959 {
18960 arg2 = wxString_in_helper(obj1);
18961 if (arg2 == NULL) SWIG_fail;
18962 temp2 = true;
18963 }
18964 {
18965 PyThreadState* __tstate = wxPyBeginAllowThreads();
18966 wxDateTime::GetAmPmStrings(arg1,arg2);
18967
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 Py_INCREF(Py_None); resultobj = Py_None;
18972 {
18973 if (temp1)
18974 delete arg1;
18975 }
18976 {
18977 if (temp2)
18978 delete arg2;
18979 }
18980 return resultobj;
18981 fail:
18982 {
18983 if (temp1)
18984 delete arg1;
18985 }
18986 {
18987 if (temp2)
18988 delete arg2;
18989 }
18990 return NULL;
18991 }
18992
18993
18994 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj;
18996 int arg1 = (int) wxDateTime::Inv_Year ;
18997 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
18998 bool result;
18999 PyObject * obj0 = 0 ;
19000 PyObject * obj1 = 0 ;
19001 char *kwnames[] = {
19002 (char *) "year",(char *) "country", NULL
19003 };
19004
19005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19006 if (obj0) {
19007 {
19008 arg1 = (int)(SWIG_As_int(obj0));
19009 if (SWIG_arg_fail(1)) SWIG_fail;
19010 }
19011 }
19012 if (obj1) {
19013 {
19014 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19015 if (SWIG_arg_fail(2)) SWIG_fail;
19016 }
19017 }
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19021
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19027 }
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj;
19036 int arg1 = (int) wxDateTime::Inv_Year ;
19037 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19038 wxDateTime result;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "year",(char *) "country", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19046 if (obj0) {
19047 {
19048 arg1 = (int)(SWIG_As_int(obj0));
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 }
19051 }
19052 if (obj1) {
19053 {
19054 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19055 if (SWIG_arg_fail(2)) SWIG_fail;
19056 }
19057 }
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19061
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 {
19066 wxDateTime * resultptr;
19067 resultptr = new wxDateTime((wxDateTime &)(result));
19068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19069 }
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19077 PyObject *resultobj;
19078 int arg1 = (int) wxDateTime::Inv_Year ;
19079 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19080 wxDateTime result;
19081 PyObject * obj0 = 0 ;
19082 PyObject * obj1 = 0 ;
19083 char *kwnames[] = {
19084 (char *) "year",(char *) "country", NULL
19085 };
19086
19087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19088 if (obj0) {
19089 {
19090 arg1 = (int)(SWIG_As_int(obj0));
19091 if (SWIG_arg_fail(1)) SWIG_fail;
19092 }
19093 }
19094 if (obj1) {
19095 {
19096 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19097 if (SWIG_arg_fail(2)) SWIG_fail;
19098 }
19099 }
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 {
19108 wxDateTime * resultptr;
19109 resultptr = new wxDateTime((wxDateTime &)(result));
19110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19111 }
19112 return resultobj;
19113 fail:
19114 return NULL;
19115 }
19116
19117
19118 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19119 PyObject *resultobj;
19120 wxDateTime result;
19121 char *kwnames[] = {
19122 NULL
19123 };
19124
19125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19126 {
19127 PyThreadState* __tstate = wxPyBeginAllowThreads();
19128 result = wxDateTime::Now();
19129
19130 wxPyEndAllowThreads(__tstate);
19131 if (PyErr_Occurred()) SWIG_fail;
19132 }
19133 {
19134 wxDateTime * resultptr;
19135 resultptr = new wxDateTime((wxDateTime &)(result));
19136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19137 }
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 wxDateTime result;
19147 char *kwnames[] = {
19148 NULL
19149 };
19150
19151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = wxDateTime::UNow();
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 {
19160 wxDateTime * resultptr;
19161 resultptr = new wxDateTime((wxDateTime &)(result));
19162 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19163 }
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj;
19172 wxDateTime result;
19173 char *kwnames[] = {
19174 NULL
19175 };
19176
19177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 result = wxDateTime::Today();
19181
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 {
19186 wxDateTime * resultptr;
19187 resultptr = new wxDateTime((wxDateTime &)(result));
19188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19189 }
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj;
19198 wxDateTime *result;
19199 char *kwnames[] = {
19200 NULL
19201 };
19202
19203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 result = (wxDateTime *)new wxDateTime();
19207
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19219 PyObject *resultobj;
19220 time_t arg1 ;
19221 wxDateTime *result;
19222 PyObject * obj0 = 0 ;
19223 char *kwnames[] = {
19224 (char *) "timet", NULL
19225 };
19226
19227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19228 {
19229 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (wxDateTime *)new wxDateTime(arg1);
19235
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 double arg1 ;
19249 wxDateTime *result;
19250 PyObject * obj0 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "jdn", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19256 {
19257 arg1 = (double)(SWIG_As_double(obj0));
19258 if (SWIG_arg_fail(1)) SWIG_fail;
19259 }
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 result = (wxDateTime *)new wxDateTime(arg1);
19263
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 int arg1 ;
19277 int arg2 = (int) 0 ;
19278 int arg3 = (int) 0 ;
19279 int arg4 = (int) 0 ;
19280 wxDateTime *result;
19281 PyObject * obj0 = 0 ;
19282 PyObject * obj1 = 0 ;
19283 PyObject * obj2 = 0 ;
19284 PyObject * obj3 = 0 ;
19285 char *kwnames[] = {
19286 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19287 };
19288
19289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19290 {
19291 arg1 = (int)(SWIG_As_int(obj0));
19292 if (SWIG_arg_fail(1)) SWIG_fail;
19293 }
19294 if (obj1) {
19295 {
19296 arg2 = (int)(SWIG_As_int(obj1));
19297 if (SWIG_arg_fail(2)) SWIG_fail;
19298 }
19299 }
19300 if (obj2) {
19301 {
19302 arg3 = (int)(SWIG_As_int(obj2));
19303 if (SWIG_arg_fail(3)) SWIG_fail;
19304 }
19305 }
19306 if (obj3) {
19307 {
19308 arg4 = (int)(SWIG_As_int(obj3));
19309 if (SWIG_arg_fail(4)) SWIG_fail;
19310 }
19311 }
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19315
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19327 PyObject *resultobj;
19328 int arg1 ;
19329 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19330 int arg3 = (int) wxDateTime::Inv_Year ;
19331 int arg4 = (int) 0 ;
19332 int arg5 = (int) 0 ;
19333 int arg6 = (int) 0 ;
19334 int arg7 = (int) 0 ;
19335 wxDateTime *result;
19336 PyObject * obj0 = 0 ;
19337 PyObject * obj1 = 0 ;
19338 PyObject * obj2 = 0 ;
19339 PyObject * obj3 = 0 ;
19340 PyObject * obj4 = 0 ;
19341 PyObject * obj5 = 0 ;
19342 PyObject * obj6 = 0 ;
19343 char *kwnames[] = {
19344 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19345 };
19346
19347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19348 {
19349 arg1 = (int)(SWIG_As_int(obj0));
19350 if (SWIG_arg_fail(1)) SWIG_fail;
19351 }
19352 if (obj1) {
19353 {
19354 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19355 if (SWIG_arg_fail(2)) SWIG_fail;
19356 }
19357 }
19358 if (obj2) {
19359 {
19360 arg3 = (int)(SWIG_As_int(obj2));
19361 if (SWIG_arg_fail(3)) SWIG_fail;
19362 }
19363 }
19364 if (obj3) {
19365 {
19366 arg4 = (int)(SWIG_As_int(obj3));
19367 if (SWIG_arg_fail(4)) SWIG_fail;
19368 }
19369 }
19370 if (obj4) {
19371 {
19372 arg5 = (int)(SWIG_As_int(obj4));
19373 if (SWIG_arg_fail(5)) SWIG_fail;
19374 }
19375 }
19376 if (obj5) {
19377 {
19378 arg6 = (int)(SWIG_As_int(obj5));
19379 if (SWIG_arg_fail(6)) SWIG_fail;
19380 }
19381 }
19382 if (obj6) {
19383 {
19384 arg7 = (int)(SWIG_As_int(obj6));
19385 if (SWIG_arg_fail(7)) SWIG_fail;
19386 }
19387 }
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 wxDateTime *arg1 = (wxDateTime *) 0 ;
19405 PyObject * obj0 = 0 ;
19406 char *kwnames[] = {
19407 (char *) "self", NULL
19408 };
19409
19410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19412 if (SWIG_arg_fail(1)) SWIG_fail;
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 delete arg1;
19416
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 Py_INCREF(Py_None); resultobj = Py_None;
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19428 PyObject *resultobj;
19429 wxDateTime *arg1 = (wxDateTime *) 0 ;
19430 wxDateTime *result;
19431 PyObject * obj0 = 0 ;
19432 char *kwnames[] = {
19433 (char *) "self", NULL
19434 };
19435
19436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 {
19442 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19443 result = (wxDateTime *) &_result_ref;
19444 }
19445
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19457 PyObject *resultobj;
19458 wxDateTime *arg1 = (wxDateTime *) 0 ;
19459 time_t arg2 ;
19460 wxDateTime *result;
19461 PyObject * obj0 = 0 ;
19462 PyObject * obj1 = 0 ;
19463 char *kwnames[] = {
19464 (char *) "self",(char *) "timet", NULL
19465 };
19466
19467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19469 if (SWIG_arg_fail(1)) SWIG_fail;
19470 {
19471 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19472 if (SWIG_arg_fail(2)) SWIG_fail;
19473 }
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 {
19477 wxDateTime &_result_ref = (arg1)->Set(arg2);
19478 result = (wxDateTime *) &_result_ref;
19479 }
19480
19481 wxPyEndAllowThreads(__tstate);
19482 if (PyErr_Occurred()) SWIG_fail;
19483 }
19484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19485 return resultobj;
19486 fail:
19487 return NULL;
19488 }
19489
19490
19491 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19492 PyObject *resultobj;
19493 wxDateTime *arg1 = (wxDateTime *) 0 ;
19494 double arg2 ;
19495 wxDateTime *result;
19496 PyObject * obj0 = 0 ;
19497 PyObject * obj1 = 0 ;
19498 char *kwnames[] = {
19499 (char *) "self",(char *) "jdn", NULL
19500 };
19501
19502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19504 if (SWIG_arg_fail(1)) SWIG_fail;
19505 {
19506 arg2 = (double)(SWIG_As_double(obj1));
19507 if (SWIG_arg_fail(2)) SWIG_fail;
19508 }
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 {
19512 wxDateTime &_result_ref = (arg1)->Set(arg2);
19513 result = (wxDateTime *) &_result_ref;
19514 }
19515
19516 wxPyEndAllowThreads(__tstate);
19517 if (PyErr_Occurred()) SWIG_fail;
19518 }
19519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj;
19528 wxDateTime *arg1 = (wxDateTime *) 0 ;
19529 int arg2 ;
19530 int arg3 = (int) 0 ;
19531 int arg4 = (int) 0 ;
19532 int arg5 = (int) 0 ;
19533 wxDateTime *result;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 PyObject * obj2 = 0 ;
19537 PyObject * obj3 = 0 ;
19538 PyObject * obj4 = 0 ;
19539 char *kwnames[] = {
19540 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19541 };
19542
19543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19545 if (SWIG_arg_fail(1)) SWIG_fail;
19546 {
19547 arg2 = (int)(SWIG_As_int(obj1));
19548 if (SWIG_arg_fail(2)) SWIG_fail;
19549 }
19550 if (obj2) {
19551 {
19552 arg3 = (int)(SWIG_As_int(obj2));
19553 if (SWIG_arg_fail(3)) SWIG_fail;
19554 }
19555 }
19556 if (obj3) {
19557 {
19558 arg4 = (int)(SWIG_As_int(obj3));
19559 if (SWIG_arg_fail(4)) SWIG_fail;
19560 }
19561 }
19562 if (obj4) {
19563 {
19564 arg5 = (int)(SWIG_As_int(obj4));
19565 if (SWIG_arg_fail(5)) SWIG_fail;
19566 }
19567 }
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 {
19571 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19572 result = (wxDateTime *) &_result_ref;
19573 }
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 wxDateTime *arg1 = (wxDateTime *) 0 ;
19588 int arg2 ;
19589 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19590 int arg4 = (int) wxDateTime::Inv_Year ;
19591 int arg5 = (int) 0 ;
19592 int arg6 = (int) 0 ;
19593 int arg7 = (int) 0 ;
19594 int arg8 = (int) 0 ;
19595 wxDateTime *result;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 PyObject * obj2 = 0 ;
19599 PyObject * obj3 = 0 ;
19600 PyObject * obj4 = 0 ;
19601 PyObject * obj5 = 0 ;
19602 PyObject * obj6 = 0 ;
19603 PyObject * obj7 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 arg2 = (int)(SWIG_As_int(obj1));
19613 if (SWIG_arg_fail(2)) SWIG_fail;
19614 }
19615 if (obj2) {
19616 {
19617 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19618 if (SWIG_arg_fail(3)) SWIG_fail;
19619 }
19620 }
19621 if (obj3) {
19622 {
19623 arg4 = (int)(SWIG_As_int(obj3));
19624 if (SWIG_arg_fail(4)) SWIG_fail;
19625 }
19626 }
19627 if (obj4) {
19628 {
19629 arg5 = (int)(SWIG_As_int(obj4));
19630 if (SWIG_arg_fail(5)) SWIG_fail;
19631 }
19632 }
19633 if (obj5) {
19634 {
19635 arg6 = (int)(SWIG_As_int(obj5));
19636 if (SWIG_arg_fail(6)) SWIG_fail;
19637 }
19638 }
19639 if (obj6) {
19640 {
19641 arg7 = (int)(SWIG_As_int(obj6));
19642 if (SWIG_arg_fail(7)) SWIG_fail;
19643 }
19644 }
19645 if (obj7) {
19646 {
19647 arg8 = (int)(SWIG_As_int(obj7));
19648 if (SWIG_arg_fail(8)) SWIG_fail;
19649 }
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 {
19654 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19655 result = (wxDateTime *) &_result_ref;
19656 }
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19662 return resultobj;
19663 fail:
19664 return NULL;
19665 }
19666
19667
19668 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19669 PyObject *resultobj;
19670 wxDateTime *arg1 = (wxDateTime *) 0 ;
19671 wxDateTime *result;
19672 PyObject * obj0 = 0 ;
19673 char *kwnames[] = {
19674 (char *) "self", NULL
19675 };
19676
19677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19679 if (SWIG_arg_fail(1)) SWIG_fail;
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 {
19683 wxDateTime &_result_ref = (arg1)->ResetTime();
19684 result = (wxDateTime *) &_result_ref;
19685 }
19686
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19698 PyObject *resultobj;
19699 wxDateTime *arg1 = (wxDateTime *) 0 ;
19700 int arg2 ;
19701 wxDateTime *result;
19702 PyObject * obj0 = 0 ;
19703 PyObject * obj1 = 0 ;
19704 char *kwnames[] = {
19705 (char *) "self",(char *) "year", NULL
19706 };
19707
19708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19710 if (SWIG_arg_fail(1)) SWIG_fail;
19711 {
19712 arg2 = (int)(SWIG_As_int(obj1));
19713 if (SWIG_arg_fail(2)) SWIG_fail;
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 {
19718 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19719 result = (wxDateTime *) &_result_ref;
19720 }
19721
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19733 PyObject *resultobj;
19734 wxDateTime *arg1 = (wxDateTime *) 0 ;
19735 wxDateTime::Month arg2 ;
19736 wxDateTime *result;
19737 PyObject * obj0 = 0 ;
19738 PyObject * obj1 = 0 ;
19739 char *kwnames[] = {
19740 (char *) "self",(char *) "month", NULL
19741 };
19742
19743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19745 if (SWIG_arg_fail(1)) SWIG_fail;
19746 {
19747 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19748 if (SWIG_arg_fail(2)) SWIG_fail;
19749 }
19750 {
19751 PyThreadState* __tstate = wxPyBeginAllowThreads();
19752 {
19753 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19754 result = (wxDateTime *) &_result_ref;
19755 }
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj;
19769 wxDateTime *arg1 = (wxDateTime *) 0 ;
19770 int arg2 ;
19771 wxDateTime *result;
19772 PyObject * obj0 = 0 ;
19773 PyObject * obj1 = 0 ;
19774 char *kwnames[] = {
19775 (char *) "self",(char *) "day", NULL
19776 };
19777
19778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 {
19782 arg2 = (int)(SWIG_As_int(obj1));
19783 if (SWIG_arg_fail(2)) SWIG_fail;
19784 }
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 {
19788 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19789 result = (wxDateTime *) &_result_ref;
19790 }
19791
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19796 return resultobj;
19797 fail:
19798 return NULL;
19799 }
19800
19801
19802 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19803 PyObject *resultobj;
19804 wxDateTime *arg1 = (wxDateTime *) 0 ;
19805 int arg2 ;
19806 wxDateTime *result;
19807 PyObject * obj0 = 0 ;
19808 PyObject * obj1 = 0 ;
19809 char *kwnames[] = {
19810 (char *) "self",(char *) "hour", NULL
19811 };
19812
19813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19815 if (SWIG_arg_fail(1)) SWIG_fail;
19816 {
19817 arg2 = (int)(SWIG_As_int(obj1));
19818 if (SWIG_arg_fail(2)) SWIG_fail;
19819 }
19820 {
19821 PyThreadState* __tstate = wxPyBeginAllowThreads();
19822 {
19823 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19824 result = (wxDateTime *) &_result_ref;
19825 }
19826
19827 wxPyEndAllowThreads(__tstate);
19828 if (PyErr_Occurred()) SWIG_fail;
19829 }
19830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19831 return resultobj;
19832 fail:
19833 return NULL;
19834 }
19835
19836
19837 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj;
19839 wxDateTime *arg1 = (wxDateTime *) 0 ;
19840 int arg2 ;
19841 wxDateTime *result;
19842 PyObject * obj0 = 0 ;
19843 PyObject * obj1 = 0 ;
19844 char *kwnames[] = {
19845 (char *) "self",(char *) "minute", NULL
19846 };
19847
19848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19850 if (SWIG_arg_fail(1)) SWIG_fail;
19851 {
19852 arg2 = (int)(SWIG_As_int(obj1));
19853 if (SWIG_arg_fail(2)) SWIG_fail;
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 {
19858 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19859 result = (wxDateTime *) &_result_ref;
19860 }
19861
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj;
19874 wxDateTime *arg1 = (wxDateTime *) 0 ;
19875 int arg2 ;
19876 wxDateTime *result;
19877 PyObject * obj0 = 0 ;
19878 PyObject * obj1 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self",(char *) "second", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 arg2 = (int)(SWIG_As_int(obj1));
19888 if (SWIG_arg_fail(2)) SWIG_fail;
19889 }
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 {
19893 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19894 result = (wxDateTime *) &_result_ref;
19895 }
19896
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19901 return resultobj;
19902 fail:
19903 return NULL;
19904 }
19905
19906
19907 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19908 PyObject *resultobj;
19909 wxDateTime *arg1 = (wxDateTime *) 0 ;
19910 int arg2 ;
19911 wxDateTime *result;
19912 PyObject * obj0 = 0 ;
19913 PyObject * obj1 = 0 ;
19914 char *kwnames[] = {
19915 (char *) "self",(char *) "millisecond", NULL
19916 };
19917
19918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19920 if (SWIG_arg_fail(1)) SWIG_fail;
19921 {
19922 arg2 = (int)(SWIG_As_int(obj1));
19923 if (SWIG_arg_fail(2)) SWIG_fail;
19924 }
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 {
19928 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19929 result = (wxDateTime *) &_result_ref;
19930 }
19931
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19943 PyObject *resultobj;
19944 wxDateTime *arg1 = (wxDateTime *) 0 ;
19945 wxDateTime::WeekDay arg2 ;
19946 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19947 wxDateTime *result;
19948 PyObject * obj0 = 0 ;
19949 PyObject * obj1 = 0 ;
19950 PyObject * obj2 = 0 ;
19951 char *kwnames[] = {
19952 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19953 };
19954
19955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19957 if (SWIG_arg_fail(1)) SWIG_fail;
19958 {
19959 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19960 if (SWIG_arg_fail(2)) SWIG_fail;
19961 }
19962 if (obj2) {
19963 {
19964 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19965 if (SWIG_arg_fail(3)) SWIG_fail;
19966 }
19967 }
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 {
19971 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19972 result = (wxDateTime *) &_result_ref;
19973 }
19974
19975 wxPyEndAllowThreads(__tstate);
19976 if (PyErr_Occurred()) SWIG_fail;
19977 }
19978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19986 PyObject *resultobj;
19987 wxDateTime *arg1 = (wxDateTime *) 0 ;
19988 wxDateTime::WeekDay arg2 ;
19989 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19990 wxDateTime result;
19991 PyObject * obj0 = 0 ;
19992 PyObject * obj1 = 0 ;
19993 PyObject * obj2 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20003 if (SWIG_arg_fail(2)) SWIG_fail;
20004 }
20005 if (obj2) {
20006 {
20007 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20008 if (SWIG_arg_fail(3)) SWIG_fail;
20009 }
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20014
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 {
20019 wxDateTime * resultptr;
20020 resultptr = new wxDateTime((wxDateTime &)(result));
20021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20030 PyObject *resultobj;
20031 wxDateTime *arg1 = (wxDateTime *) 0 ;
20032 wxDateTime::WeekDay arg2 ;
20033 wxDateTime *result;
20034 PyObject * obj0 = 0 ;
20035 PyObject * obj1 = 0 ;
20036 char *kwnames[] = {
20037 (char *) "self",(char *) "weekday", NULL
20038 };
20039
20040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20042 if (SWIG_arg_fail(1)) SWIG_fail;
20043 {
20044 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20045 if (SWIG_arg_fail(2)) SWIG_fail;
20046 }
20047 {
20048 PyThreadState* __tstate = wxPyBeginAllowThreads();
20049 {
20050 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20051 result = (wxDateTime *) &_result_ref;
20052 }
20053
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj;
20066 wxDateTime *arg1 = (wxDateTime *) 0 ;
20067 wxDateTime::WeekDay arg2 ;
20068 wxDateTime result;
20069 PyObject * obj0 = 0 ;
20070 PyObject * obj1 = 0 ;
20071 char *kwnames[] = {
20072 (char *) "self",(char *) "weekday", NULL
20073 };
20074
20075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20077 if (SWIG_arg_fail(1)) SWIG_fail;
20078 {
20079 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20080 if (SWIG_arg_fail(2)) SWIG_fail;
20081 }
20082 {
20083 PyThreadState* __tstate = wxPyBeginAllowThreads();
20084 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20085
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 {
20090 wxDateTime * resultptr;
20091 resultptr = new wxDateTime((wxDateTime &)(result));
20092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20093 }
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDateTime *arg1 = (wxDateTime *) 0 ;
20103 wxDateTime::WeekDay arg2 ;
20104 wxDateTime *result;
20105 PyObject * obj0 = 0 ;
20106 PyObject * obj1 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "self",(char *) "weekday", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 {
20115 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20116 if (SWIG_arg_fail(2)) SWIG_fail;
20117 }
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 {
20121 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20122 result = (wxDateTime *) &_result_ref;
20123 }
20124
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20129 return resultobj;
20130 fail:
20131 return NULL;
20132 }
20133
20134
20135 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20136 PyObject *resultobj;
20137 wxDateTime *arg1 = (wxDateTime *) 0 ;
20138 wxDateTime::WeekDay arg2 ;
20139 wxDateTime result;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 char *kwnames[] = {
20143 (char *) "self",(char *) "weekday", NULL
20144 };
20145
20146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20148 if (SWIG_arg_fail(1)) SWIG_fail;
20149 {
20150 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20151 if (SWIG_arg_fail(2)) SWIG_fail;
20152 }
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20156
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 {
20161 wxDateTime * resultptr;
20162 resultptr = new wxDateTime((wxDateTime &)(result));
20163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20164 }
20165 return resultobj;
20166 fail:
20167 return NULL;
20168 }
20169
20170
20171 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20172 PyObject *resultobj;
20173 wxDateTime *arg1 = (wxDateTime *) 0 ;
20174 wxDateTime::WeekDay arg2 ;
20175 int arg3 = (int) 1 ;
20176 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20177 int arg5 = (int) wxDateTime::Inv_Year ;
20178 bool result;
20179 PyObject * obj0 = 0 ;
20180 PyObject * obj1 = 0 ;
20181 PyObject * obj2 = 0 ;
20182 PyObject * obj3 = 0 ;
20183 PyObject * obj4 = 0 ;
20184 char *kwnames[] = {
20185 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20186 };
20187
20188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20190 if (SWIG_arg_fail(1)) SWIG_fail;
20191 {
20192 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20193 if (SWIG_arg_fail(2)) SWIG_fail;
20194 }
20195 if (obj2) {
20196 {
20197 arg3 = (int)(SWIG_As_int(obj2));
20198 if (SWIG_arg_fail(3)) SWIG_fail;
20199 }
20200 }
20201 if (obj3) {
20202 {
20203 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20204 if (SWIG_arg_fail(4)) SWIG_fail;
20205 }
20206 }
20207 if (obj4) {
20208 {
20209 arg5 = (int)(SWIG_As_int(obj4));
20210 if (SWIG_arg_fail(5)) SWIG_fail;
20211 }
20212 }
20213 {
20214 PyThreadState* __tstate = wxPyBeginAllowThreads();
20215 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20216
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 {
20221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20222 }
20223 return resultobj;
20224 fail:
20225 return NULL;
20226 }
20227
20228
20229 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20230 PyObject *resultobj;
20231 wxDateTime *arg1 = (wxDateTime *) 0 ;
20232 wxDateTime::WeekDay arg2 ;
20233 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20234 int arg4 = (int) wxDateTime::Inv_Year ;
20235 bool result;
20236 PyObject * obj0 = 0 ;
20237 PyObject * obj1 = 0 ;
20238 PyObject * obj2 = 0 ;
20239 PyObject * obj3 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(1)) SWIG_fail;
20247 {
20248 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20249 if (SWIG_arg_fail(2)) SWIG_fail;
20250 }
20251 if (obj2) {
20252 {
20253 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20254 if (SWIG_arg_fail(3)) SWIG_fail;
20255 }
20256 }
20257 if (obj3) {
20258 {
20259 arg4 = (int)(SWIG_As_int(obj3));
20260 if (SWIG_arg_fail(4)) SWIG_fail;
20261 }
20262 }
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20266
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 {
20271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxDateTime *arg1 = (wxDateTime *) 0 ;
20282 wxDateTime::WeekDay arg2 ;
20283 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20284 int arg4 = (int) wxDateTime::Inv_Year ;
20285 wxDateTime result;
20286 PyObject * obj0 = 0 ;
20287 PyObject * obj1 = 0 ;
20288 PyObject * obj2 = 0 ;
20289 PyObject * obj3 = 0 ;
20290 char *kwnames[] = {
20291 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20292 };
20293
20294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20296 if (SWIG_arg_fail(1)) SWIG_fail;
20297 {
20298 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20299 if (SWIG_arg_fail(2)) SWIG_fail;
20300 }
20301 if (obj2) {
20302 {
20303 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20304 if (SWIG_arg_fail(3)) SWIG_fail;
20305 }
20306 }
20307 if (obj3) {
20308 {
20309 arg4 = (int)(SWIG_As_int(obj3));
20310 if (SWIG_arg_fail(4)) SWIG_fail;
20311 }
20312 }
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20316
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 wxDateTime * resultptr;
20322 resultptr = new wxDateTime((wxDateTime &)(result));
20323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20324 }
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj;
20333 wxDateTime *arg1 = (wxDateTime *) 0 ;
20334 int arg2 ;
20335 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20336 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20337 bool result;
20338 PyObject * obj0 = 0 ;
20339 PyObject * obj1 = 0 ;
20340 PyObject * obj2 = 0 ;
20341 PyObject * obj3 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 arg2 = (int)(SWIG_As_int(obj1));
20351 if (SWIG_arg_fail(2)) SWIG_fail;
20352 }
20353 if (obj2) {
20354 {
20355 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20356 if (SWIG_arg_fail(3)) SWIG_fail;
20357 }
20358 }
20359 if (obj3) {
20360 {
20361 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20362 if (SWIG_arg_fail(4)) SWIG_fail;
20363 }
20364 }
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20374 }
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20382 PyObject *resultobj;
20383 wxDateTime *arg1 = (wxDateTime *) 0 ;
20384 int arg2 ;
20385 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20386 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20387 wxDateTime result;
20388 PyObject * obj0 = 0 ;
20389 PyObject * obj1 = 0 ;
20390 PyObject * obj2 = 0 ;
20391 PyObject * obj3 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 arg2 = (int)(SWIG_As_int(obj1));
20401 if (SWIG_arg_fail(2)) SWIG_fail;
20402 }
20403 if (obj2) {
20404 {
20405 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20406 if (SWIG_arg_fail(3)) SWIG_fail;
20407 }
20408 }
20409 if (obj3) {
20410 {
20411 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20412 if (SWIG_arg_fail(4)) SWIG_fail;
20413 }
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
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_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20434 PyObject *resultobj;
20435 int arg1 ;
20436 int arg2 ;
20437 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20438 wxDateTime result;
20439 PyObject * obj0 = 0 ;
20440 PyObject * obj1 = 0 ;
20441 PyObject * obj2 = 0 ;
20442 char *kwnames[] = {
20443 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20444 };
20445
20446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20447 {
20448 arg1 = (int)(SWIG_As_int(obj0));
20449 if (SWIG_arg_fail(1)) SWIG_fail;
20450 }
20451 {
20452 arg2 = (int)(SWIG_As_int(obj1));
20453 if (SWIG_arg_fail(2)) SWIG_fail;
20454 }
20455 if (obj2) {
20456 {
20457 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20458 if (SWIG_arg_fail(3)) SWIG_fail;
20459 }
20460 }
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20464
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 {
20469 wxDateTime * resultptr;
20470 resultptr = new wxDateTime((wxDateTime &)(result));
20471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20480 PyObject *resultobj;
20481 wxDateTime *arg1 = (wxDateTime *) 0 ;
20482 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20483 int arg3 = (int) wxDateTime::Inv_Year ;
20484 wxDateTime *result;
20485 PyObject * obj0 = 0 ;
20486 PyObject * obj1 = 0 ;
20487 PyObject * obj2 = 0 ;
20488 char *kwnames[] = {
20489 (char *) "self",(char *) "month",(char *) "year", NULL
20490 };
20491
20492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20494 if (SWIG_arg_fail(1)) SWIG_fail;
20495 if (obj1) {
20496 {
20497 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20498 if (SWIG_arg_fail(2)) SWIG_fail;
20499 }
20500 }
20501 if (obj2) {
20502 {
20503 arg3 = (int)(SWIG_As_int(obj2));
20504 if (SWIG_arg_fail(3)) SWIG_fail;
20505 }
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 {
20510 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20511 result = (wxDateTime *) &_result_ref;
20512 }
20513
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20525 PyObject *resultobj;
20526 wxDateTime *arg1 = (wxDateTime *) 0 ;
20527 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20528 int arg3 = (int) wxDateTime::Inv_Year ;
20529 wxDateTime result;
20530 PyObject * obj0 = 0 ;
20531 PyObject * obj1 = 0 ;
20532 PyObject * obj2 = 0 ;
20533 char *kwnames[] = {
20534 (char *) "self",(char *) "month",(char *) "year", NULL
20535 };
20536
20537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20539 if (SWIG_arg_fail(1)) SWIG_fail;
20540 if (obj1) {
20541 {
20542 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20543 if (SWIG_arg_fail(2)) SWIG_fail;
20544 }
20545 }
20546 if (obj2) {
20547 {
20548 arg3 = (int)(SWIG_As_int(obj2));
20549 if (SWIG_arg_fail(3)) SWIG_fail;
20550 }
20551 }
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20555
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 {
20560 wxDateTime * resultptr;
20561 resultptr = new wxDateTime((wxDateTime &)(result));
20562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20563 }
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj;
20572 wxDateTime *arg1 = (wxDateTime *) 0 ;
20573 int arg2 ;
20574 wxDateTime *result;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "self",(char *) "yday", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 {
20585 arg2 = (int)(SWIG_As_int(obj1));
20586 if (SWIG_arg_fail(2)) SWIG_fail;
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 {
20591 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20592 result = (wxDateTime *) &_result_ref;
20593 }
20594
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20599 return resultobj;
20600 fail:
20601 return NULL;
20602 }
20603
20604
20605 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20606 PyObject *resultobj;
20607 wxDateTime *arg1 = (wxDateTime *) 0 ;
20608 int arg2 ;
20609 wxDateTime result;
20610 PyObject * obj0 = 0 ;
20611 PyObject * obj1 = 0 ;
20612 char *kwnames[] = {
20613 (char *) "self",(char *) "yday", NULL
20614 };
20615
20616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20618 if (SWIG_arg_fail(1)) SWIG_fail;
20619 {
20620 arg2 = (int)(SWIG_As_int(obj1));
20621 if (SWIG_arg_fail(2)) SWIG_fail;
20622 }
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (arg1)->GetYearDay(arg2);
20626
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 wxDateTime * resultptr;
20632 resultptr = new wxDateTime((wxDateTime &)(result));
20633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20634 }
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20642 PyObject *resultobj;
20643 wxDateTime *arg1 = (wxDateTime *) 0 ;
20644 double result;
20645 PyObject * obj0 = 0 ;
20646 char *kwnames[] = {
20647 (char *) "self", NULL
20648 };
20649
20650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20652 if (SWIG_arg_fail(1)) SWIG_fail;
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 result = (double)(arg1)->GetJulianDayNumber();
20656
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = SWIG_From_double((double)(result));
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj;
20671 wxDateTime *arg1 = (wxDateTime *) 0 ;
20672 double result;
20673 PyObject * obj0 = 0 ;
20674 char *kwnames[] = {
20675 (char *) "self", NULL
20676 };
20677
20678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20680 if (SWIG_arg_fail(1)) SWIG_fail;
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (double)(arg1)->GetJDN();
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 resultobj = SWIG_From_double((double)(result));
20690 }
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20698 PyObject *resultobj;
20699 wxDateTime *arg1 = (wxDateTime *) 0 ;
20700 double result;
20701 PyObject * obj0 = 0 ;
20702 char *kwnames[] = {
20703 (char *) "self", NULL
20704 };
20705
20706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20708 if (SWIG_arg_fail(1)) SWIG_fail;
20709 {
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20712
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 {
20717 resultobj = SWIG_From_double((double)(result));
20718 }
20719 return resultobj;
20720 fail:
20721 return NULL;
20722 }
20723
20724
20725 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20726 PyObject *resultobj;
20727 wxDateTime *arg1 = (wxDateTime *) 0 ;
20728 double result;
20729 PyObject * obj0 = 0 ;
20730 char *kwnames[] = {
20731 (char *) "self", NULL
20732 };
20733
20734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20736 if (SWIG_arg_fail(1)) SWIG_fail;
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 result = (double)(arg1)->GetMJD();
20740
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 {
20745 resultobj = SWIG_From_double((double)(result));
20746 }
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20754 PyObject *resultobj;
20755 wxDateTime *arg1 = (wxDateTime *) 0 ;
20756 double result;
20757 PyObject * obj0 = 0 ;
20758 char *kwnames[] = {
20759 (char *) "self", NULL
20760 };
20761
20762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20764 if (SWIG_arg_fail(1)) SWIG_fail;
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 result = (double)(arg1)->GetRataDie();
20768
20769 wxPyEndAllowThreads(__tstate);
20770 if (PyErr_Occurred()) SWIG_fail;
20771 }
20772 {
20773 resultobj = SWIG_From_double((double)(result));
20774 }
20775 return resultobj;
20776 fail:
20777 return NULL;
20778 }
20779
20780
20781 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 wxDateTime *arg1 = (wxDateTime *) 0 ;
20784 wxDateTime::TimeZone *arg2 = 0 ;
20785 bool arg3 = (bool) false ;
20786 wxDateTime result;
20787 bool temp2 = false ;
20788 PyObject * obj0 = 0 ;
20789 PyObject * obj1 = 0 ;
20790 PyObject * obj2 = 0 ;
20791 char *kwnames[] = {
20792 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20793 };
20794
20795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20797 if (SWIG_arg_fail(1)) SWIG_fail;
20798 {
20799 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20800 temp2 = true;
20801 }
20802 if (obj2) {
20803 {
20804 arg3 = (bool)(SWIG_As_bool(obj2));
20805 if (SWIG_arg_fail(3)) SWIG_fail;
20806 }
20807 }
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 {
20816 wxDateTime * resultptr;
20817 resultptr = new wxDateTime((wxDateTime &)(result));
20818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20819 }
20820 {
20821 if (temp2) delete arg2;
20822 }
20823 return resultobj;
20824 fail:
20825 {
20826 if (temp2) delete arg2;
20827 }
20828 return NULL;
20829 }
20830
20831
20832 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20833 PyObject *resultobj;
20834 wxDateTime *arg1 = (wxDateTime *) 0 ;
20835 wxDateTime::TimeZone *arg2 = 0 ;
20836 bool arg3 = (bool) false ;
20837 wxDateTime *result;
20838 bool temp2 = false ;
20839 PyObject * obj0 = 0 ;
20840 PyObject * obj1 = 0 ;
20841 PyObject * obj2 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20848 if (SWIG_arg_fail(1)) SWIG_fail;
20849 {
20850 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20851 temp2 = true;
20852 }
20853 if (obj2) {
20854 {
20855 arg3 = (bool)(SWIG_As_bool(obj2));
20856 if (SWIG_arg_fail(3)) SWIG_fail;
20857 }
20858 }
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 {
20862 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20863 result = (wxDateTime *) &_result_ref;
20864 }
20865
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20870 {
20871 if (temp2) delete arg2;
20872 }
20873 return resultobj;
20874 fail:
20875 {
20876 if (temp2) delete arg2;
20877 }
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj;
20884 wxDateTime *arg1 = (wxDateTime *) 0 ;
20885 bool arg2 = (bool) false ;
20886 wxDateTime result;
20887 PyObject * obj0 = 0 ;
20888 PyObject * obj1 = 0 ;
20889 char *kwnames[] = {
20890 (char *) "self",(char *) "noDST", NULL
20891 };
20892
20893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20895 if (SWIG_arg_fail(1)) SWIG_fail;
20896 if (obj1) {
20897 {
20898 arg2 = (bool)(SWIG_As_bool(obj1));
20899 if (SWIG_arg_fail(2)) SWIG_fail;
20900 }
20901 }
20902 {
20903 PyThreadState* __tstate = wxPyBeginAllowThreads();
20904 result = (arg1)->ToGMT(arg2);
20905
20906 wxPyEndAllowThreads(__tstate);
20907 if (PyErr_Occurred()) SWIG_fail;
20908 }
20909 {
20910 wxDateTime * resultptr;
20911 resultptr = new wxDateTime((wxDateTime &)(result));
20912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20913 }
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj;
20922 wxDateTime *arg1 = (wxDateTime *) 0 ;
20923 bool arg2 = (bool) false ;
20924 wxDateTime *result;
20925 PyObject * obj0 = 0 ;
20926 PyObject * obj1 = 0 ;
20927 char *kwnames[] = {
20928 (char *) "self",(char *) "noDST", NULL
20929 };
20930
20931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20933 if (SWIG_arg_fail(1)) SWIG_fail;
20934 if (obj1) {
20935 {
20936 arg2 = (bool)(SWIG_As_bool(obj1));
20937 if (SWIG_arg_fail(2)) SWIG_fail;
20938 }
20939 }
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 {
20943 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20944 result = (wxDateTime *) &_result_ref;
20945 }
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxDateTime *arg1 = (wxDateTime *) 0 ;
20960 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20961 int result;
20962 PyObject * obj0 = 0 ;
20963 PyObject * obj1 = 0 ;
20964 char *kwnames[] = {
20965 (char *) "self",(char *) "country", NULL
20966 };
20967
20968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20970 if (SWIG_arg_fail(1)) SWIG_fail;
20971 if (obj1) {
20972 {
20973 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20974 if (SWIG_arg_fail(2)) SWIG_fail;
20975 }
20976 }
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20980
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 resultobj = SWIG_From_int((int)(result));
20986 }
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj;
20995 wxDateTime *arg1 = (wxDateTime *) 0 ;
20996 bool result;
20997 PyObject * obj0 = 0 ;
20998 char *kwnames[] = {
20999 (char *) "self", NULL
21000 };
21001
21002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21004 if (SWIG_arg_fail(1)) SWIG_fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (bool)((wxDateTime const *)arg1)->IsValid();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 {
21013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21014 }
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21022 PyObject *resultobj;
21023 wxDateTime *arg1 = (wxDateTime *) 0 ;
21024 time_t result;
21025 PyObject * obj0 = 0 ;
21026 char *kwnames[] = {
21027 (char *) "self", NULL
21028 };
21029
21030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21032 if (SWIG_arg_fail(1)) SWIG_fail;
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 {
21041 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21042 }
21043 return resultobj;
21044 fail:
21045 return NULL;
21046 }
21047
21048
21049 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21050 PyObject *resultobj;
21051 wxDateTime *arg1 = (wxDateTime *) 0 ;
21052 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21053 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21054 int result;
21055 bool temp2 = false ;
21056 PyObject * obj0 = 0 ;
21057 PyObject * obj1 = 0 ;
21058 char *kwnames[] = {
21059 (char *) "self",(char *) "tz", NULL
21060 };
21061
21062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21064 if (SWIG_arg_fail(1)) SWIG_fail;
21065 if (obj1) {
21066 {
21067 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21068 temp2 = true;
21069 }
21070 }
21071 {
21072 PyThreadState* __tstate = wxPyBeginAllowThreads();
21073 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21074
21075 wxPyEndAllowThreads(__tstate);
21076 if (PyErr_Occurred()) SWIG_fail;
21077 }
21078 {
21079 resultobj = SWIG_From_int((int)(result));
21080 }
21081 {
21082 if (temp2) delete arg2;
21083 }
21084 return resultobj;
21085 fail:
21086 {
21087 if (temp2) delete arg2;
21088 }
21089 return NULL;
21090 }
21091
21092
21093 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj;
21095 wxDateTime *arg1 = (wxDateTime *) 0 ;
21096 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21097 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21098 wxDateTime::Month result;
21099 bool temp2 = false ;
21100 PyObject * obj0 = 0 ;
21101 PyObject * obj1 = 0 ;
21102 char *kwnames[] = {
21103 (char *) "self",(char *) "tz", NULL
21104 };
21105
21106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21108 if (SWIG_arg_fail(1)) SWIG_fail;
21109 if (obj1) {
21110 {
21111 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21112 temp2 = true;
21113 }
21114 }
21115 {
21116 PyThreadState* __tstate = wxPyBeginAllowThreads();
21117 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21118
21119 wxPyEndAllowThreads(__tstate);
21120 if (PyErr_Occurred()) SWIG_fail;
21121 }
21122 resultobj = SWIG_From_int((result));
21123 {
21124 if (temp2) delete arg2;
21125 }
21126 return resultobj;
21127 fail:
21128 {
21129 if (temp2) delete arg2;
21130 }
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxDateTime *arg1 = (wxDateTime *) 0 ;
21138 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21139 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21140 int result;
21141 bool temp2 = false ;
21142 PyObject * obj0 = 0 ;
21143 PyObject * obj1 = 0 ;
21144 char *kwnames[] = {
21145 (char *) "self",(char *) "tz", NULL
21146 };
21147
21148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21150 if (SWIG_arg_fail(1)) SWIG_fail;
21151 if (obj1) {
21152 {
21153 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21154 temp2 = true;
21155 }
21156 }
21157 {
21158 PyThreadState* __tstate = wxPyBeginAllowThreads();
21159 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21160
21161 wxPyEndAllowThreads(__tstate);
21162 if (PyErr_Occurred()) SWIG_fail;
21163 }
21164 {
21165 resultobj = SWIG_From_int((int)(result));
21166 }
21167 {
21168 if (temp2) delete arg2;
21169 }
21170 return resultobj;
21171 fail:
21172 {
21173 if (temp2) delete arg2;
21174 }
21175 return NULL;
21176 }
21177
21178
21179 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21180 PyObject *resultobj;
21181 wxDateTime *arg1 = (wxDateTime *) 0 ;
21182 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21183 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21184 wxDateTime::WeekDay result;
21185 bool temp2 = false ;
21186 PyObject * obj0 = 0 ;
21187 PyObject * obj1 = 0 ;
21188 char *kwnames[] = {
21189 (char *) "self",(char *) "tz", NULL
21190 };
21191
21192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21194 if (SWIG_arg_fail(1)) SWIG_fail;
21195 if (obj1) {
21196 {
21197 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21198 temp2 = true;
21199 }
21200 }
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 resultobj = SWIG_From_int((result));
21209 {
21210 if (temp2) delete arg2;
21211 }
21212 return resultobj;
21213 fail:
21214 {
21215 if (temp2) delete arg2;
21216 }
21217 return NULL;
21218 }
21219
21220
21221 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21222 PyObject *resultobj;
21223 wxDateTime *arg1 = (wxDateTime *) 0 ;
21224 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21225 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21226 int result;
21227 bool temp2 = false ;
21228 PyObject * obj0 = 0 ;
21229 PyObject * obj1 = 0 ;
21230 char *kwnames[] = {
21231 (char *) "self",(char *) "tz", NULL
21232 };
21233
21234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(1)) SWIG_fail;
21237 if (obj1) {
21238 {
21239 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21240 temp2 = true;
21241 }
21242 }
21243 {
21244 PyThreadState* __tstate = wxPyBeginAllowThreads();
21245 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21246
21247 wxPyEndAllowThreads(__tstate);
21248 if (PyErr_Occurred()) SWIG_fail;
21249 }
21250 {
21251 resultobj = SWIG_From_int((int)(result));
21252 }
21253 {
21254 if (temp2) delete arg2;
21255 }
21256 return resultobj;
21257 fail:
21258 {
21259 if (temp2) delete arg2;
21260 }
21261 return NULL;
21262 }
21263
21264
21265 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj;
21267 wxDateTime *arg1 = (wxDateTime *) 0 ;
21268 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21269 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21270 int result;
21271 bool temp2 = false ;
21272 PyObject * obj0 = 0 ;
21273 PyObject * obj1 = 0 ;
21274 char *kwnames[] = {
21275 (char *) "self",(char *) "tz", NULL
21276 };
21277
21278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21280 if (SWIG_arg_fail(1)) SWIG_fail;
21281 if (obj1) {
21282 {
21283 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21284 temp2 = true;
21285 }
21286 }
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21290
21291 wxPyEndAllowThreads(__tstate);
21292 if (PyErr_Occurred()) SWIG_fail;
21293 }
21294 {
21295 resultobj = SWIG_From_int((int)(result));
21296 }
21297 {
21298 if (temp2) delete arg2;
21299 }
21300 return resultobj;
21301 fail:
21302 {
21303 if (temp2) delete arg2;
21304 }
21305 return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxDateTime *arg1 = (wxDateTime *) 0 ;
21312 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21313 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21314 int result;
21315 bool temp2 = false ;
21316 PyObject * obj0 = 0 ;
21317 PyObject * obj1 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self",(char *) "tz", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 if (obj1) {
21326 {
21327 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21328 temp2 = true;
21329 }
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 {
21339 resultobj = SWIG_From_int((int)(result));
21340 }
21341 {
21342 if (temp2) delete arg2;
21343 }
21344 return resultobj;
21345 fail:
21346 {
21347 if (temp2) delete arg2;
21348 }
21349 return NULL;
21350 }
21351
21352
21353 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxDateTime *arg1 = (wxDateTime *) 0 ;
21356 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21357 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21358 int result;
21359 bool temp2 = false ;
21360 PyObject * obj0 = 0 ;
21361 PyObject * obj1 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "self",(char *) "tz", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 if (obj1) {
21370 {
21371 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21372 temp2 = true;
21373 }
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 resultobj = SWIG_From_int((int)(result));
21384 }
21385 {
21386 if (temp2) delete arg2;
21387 }
21388 return resultobj;
21389 fail:
21390 {
21391 if (temp2) delete arg2;
21392 }
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj;
21399 wxDateTime *arg1 = (wxDateTime *) 0 ;
21400 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21401 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21402 int result;
21403 bool temp2 = false ;
21404 PyObject * obj0 = 0 ;
21405 PyObject * obj1 = 0 ;
21406 char *kwnames[] = {
21407 (char *) "self",(char *) "tz", NULL
21408 };
21409
21410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21412 if (SWIG_arg_fail(1)) SWIG_fail;
21413 if (obj1) {
21414 {
21415 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21416 temp2 = true;
21417 }
21418 }
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 {
21427 resultobj = SWIG_From_int((int)(result));
21428 }
21429 {
21430 if (temp2) delete arg2;
21431 }
21432 return resultobj;
21433 fail:
21434 {
21435 if (temp2) delete arg2;
21436 }
21437 return NULL;
21438 }
21439
21440
21441 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj;
21443 wxDateTime *arg1 = (wxDateTime *) 0 ;
21444 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21445 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21446 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21447 int result;
21448 bool temp3 = false ;
21449 PyObject * obj0 = 0 ;
21450 PyObject * obj1 = 0 ;
21451 PyObject * obj2 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self",(char *) "flags",(char *) "tz", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 if (obj1) {
21460 {
21461 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21462 if (SWIG_arg_fail(2)) SWIG_fail;
21463 }
21464 }
21465 if (obj2) {
21466 {
21467 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21468 temp3 = true;
21469 }
21470 }
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 {
21479 resultobj = SWIG_From_int((int)(result));
21480 }
21481 {
21482 if (temp3) delete arg3;
21483 }
21484 return resultobj;
21485 fail:
21486 {
21487 if (temp3) delete arg3;
21488 }
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxDateTime *arg1 = (wxDateTime *) 0 ;
21496 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21497 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21498 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21499 int result;
21500 bool temp3 = false ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 PyObject * obj2 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self",(char *) "flags",(char *) "tz", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 if (obj1) {
21512 {
21513 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21514 if (SWIG_arg_fail(2)) SWIG_fail;
21515 }
21516 }
21517 if (obj2) {
21518 {
21519 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21520 temp3 = true;
21521 }
21522 }
21523 {
21524 PyThreadState* __tstate = wxPyBeginAllowThreads();
21525 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21526
21527 wxPyEndAllowThreads(__tstate);
21528 if (PyErr_Occurred()) SWIG_fail;
21529 }
21530 {
21531 resultobj = SWIG_From_int((int)(result));
21532 }
21533 {
21534 if (temp3) delete arg3;
21535 }
21536 return resultobj;
21537 fail:
21538 {
21539 if (temp3) delete arg3;
21540 }
21541 return NULL;
21542 }
21543
21544
21545 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj;
21547 wxDateTime *arg1 = (wxDateTime *) 0 ;
21548 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21549 bool result;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "self",(char *) "country", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21558 if (SWIG_arg_fail(1)) SWIG_fail;
21559 if (obj1) {
21560 {
21561 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21562 if (SWIG_arg_fail(2)) SWIG_fail;
21563 }
21564 }
21565 {
21566 PyThreadState* __tstate = wxPyBeginAllowThreads();
21567 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21568
21569 wxPyEndAllowThreads(__tstate);
21570 if (PyErr_Occurred()) SWIG_fail;
21571 }
21572 {
21573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21574 }
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21582 PyObject *resultobj;
21583 wxDateTime *arg1 = (wxDateTime *) 0 ;
21584 wxDateTime *arg2 = 0 ;
21585 bool result;
21586 PyObject * obj0 = 0 ;
21587 PyObject * obj1 = 0 ;
21588 char *kwnames[] = {
21589 (char *) "self",(char *) "datetime", NULL
21590 };
21591
21592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21594 if (SWIG_arg_fail(1)) SWIG_fail;
21595 {
21596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21597 if (SWIG_arg_fail(2)) SWIG_fail;
21598 if (arg2 == NULL) {
21599 SWIG_null_ref("wxDateTime");
21600 }
21601 if (SWIG_arg_fail(2)) SWIG_fail;
21602 }
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21612 }
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxDateTime *arg1 = (wxDateTime *) 0 ;
21622 wxDateTime *arg2 = 0 ;
21623 bool result;
21624 PyObject * obj0 = 0 ;
21625 PyObject * obj1 = 0 ;
21626 char *kwnames[] = {
21627 (char *) "self",(char *) "datetime", NULL
21628 };
21629
21630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 {
21634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(2)) SWIG_fail;
21636 if (arg2 == NULL) {
21637 SWIG_null_ref("wxDateTime");
21638 }
21639 if (SWIG_arg_fail(2)) SWIG_fail;
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 {
21649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21650 }
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxDateTime *arg1 = (wxDateTime *) 0 ;
21660 wxDateTime *arg2 = 0 ;
21661 bool result;
21662 PyObject * obj0 = 0 ;
21663 PyObject * obj1 = 0 ;
21664 char *kwnames[] = {
21665 (char *) "self",(char *) "datetime", NULL
21666 };
21667
21668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21670 if (SWIG_arg_fail(1)) SWIG_fail;
21671 {
21672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21673 if (SWIG_arg_fail(2)) SWIG_fail;
21674 if (arg2 == NULL) {
21675 SWIG_null_ref("wxDateTime");
21676 }
21677 if (SWIG_arg_fail(2)) SWIG_fail;
21678 }
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21688 }
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21696 PyObject *resultobj;
21697 wxDateTime *arg1 = (wxDateTime *) 0 ;
21698 wxDateTime *arg2 = 0 ;
21699 wxDateTime *arg3 = 0 ;
21700 bool result;
21701 PyObject * obj0 = 0 ;
21702 PyObject * obj1 = 0 ;
21703 PyObject * obj2 = 0 ;
21704 char *kwnames[] = {
21705 (char *) "self",(char *) "t1",(char *) "t2", NULL
21706 };
21707
21708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21710 if (SWIG_arg_fail(1)) SWIG_fail;
21711 {
21712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21713 if (SWIG_arg_fail(2)) SWIG_fail;
21714 if (arg2 == NULL) {
21715 SWIG_null_ref("wxDateTime");
21716 }
21717 if (SWIG_arg_fail(2)) SWIG_fail;
21718 }
21719 {
21720 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21721 if (SWIG_arg_fail(3)) SWIG_fail;
21722 if (arg3 == NULL) {
21723 SWIG_null_ref("wxDateTime");
21724 }
21725 if (SWIG_arg_fail(3)) SWIG_fail;
21726 }
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 {
21735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21736 }
21737 return resultobj;
21738 fail:
21739 return NULL;
21740 }
21741
21742
21743 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj;
21745 wxDateTime *arg1 = (wxDateTime *) 0 ;
21746 wxDateTime *arg2 = 0 ;
21747 wxDateTime *arg3 = 0 ;
21748 bool result;
21749 PyObject * obj0 = 0 ;
21750 PyObject * obj1 = 0 ;
21751 PyObject * obj2 = 0 ;
21752 char *kwnames[] = {
21753 (char *) "self",(char *) "t1",(char *) "t2", NULL
21754 };
21755
21756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21758 if (SWIG_arg_fail(1)) SWIG_fail;
21759 {
21760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21761 if (SWIG_arg_fail(2)) SWIG_fail;
21762 if (arg2 == NULL) {
21763 SWIG_null_ref("wxDateTime");
21764 }
21765 if (SWIG_arg_fail(2)) SWIG_fail;
21766 }
21767 {
21768 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21769 if (SWIG_arg_fail(3)) SWIG_fail;
21770 if (arg3 == NULL) {
21771 SWIG_null_ref("wxDateTime");
21772 }
21773 if (SWIG_arg_fail(3)) SWIG_fail;
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 {
21783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21784 }
21785 return resultobj;
21786 fail:
21787 return NULL;
21788 }
21789
21790
21791 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj;
21793 wxDateTime *arg1 = (wxDateTime *) 0 ;
21794 wxDateTime *arg2 = 0 ;
21795 bool result;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "self",(char *) "dt", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 {
21806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21807 if (SWIG_arg_fail(2)) SWIG_fail;
21808 if (arg2 == NULL) {
21809 SWIG_null_ref("wxDateTime");
21810 }
21811 if (SWIG_arg_fail(2)) SWIG_fail;
21812 }
21813 {
21814 PyThreadState* __tstate = wxPyBeginAllowThreads();
21815 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21816
21817 wxPyEndAllowThreads(__tstate);
21818 if (PyErr_Occurred()) SWIG_fail;
21819 }
21820 {
21821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21822 }
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj;
21831 wxDateTime *arg1 = (wxDateTime *) 0 ;
21832 wxDateTime *arg2 = 0 ;
21833 bool result;
21834 PyObject * obj0 = 0 ;
21835 PyObject * obj1 = 0 ;
21836 char *kwnames[] = {
21837 (char *) "self",(char *) "dt", NULL
21838 };
21839
21840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21842 if (SWIG_arg_fail(1)) SWIG_fail;
21843 {
21844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21845 if (SWIG_arg_fail(2)) SWIG_fail;
21846 if (arg2 == NULL) {
21847 SWIG_null_ref("wxDateTime");
21848 }
21849 if (SWIG_arg_fail(2)) SWIG_fail;
21850 }
21851 {
21852 PyThreadState* __tstate = wxPyBeginAllowThreads();
21853 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21854
21855 wxPyEndAllowThreads(__tstate);
21856 if (PyErr_Occurred()) SWIG_fail;
21857 }
21858 {
21859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21860 }
21861 return resultobj;
21862 fail:
21863 return NULL;
21864 }
21865
21866
21867 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21868 PyObject *resultobj;
21869 wxDateTime *arg1 = (wxDateTime *) 0 ;
21870 wxDateTime *arg2 = 0 ;
21871 wxTimeSpan *arg3 = 0 ;
21872 bool result;
21873 PyObject * obj0 = 0 ;
21874 PyObject * obj1 = 0 ;
21875 PyObject * obj2 = 0 ;
21876 char *kwnames[] = {
21877 (char *) "self",(char *) "dt",(char *) "ts", NULL
21878 };
21879
21880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21882 if (SWIG_arg_fail(1)) SWIG_fail;
21883 {
21884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21885 if (SWIG_arg_fail(2)) SWIG_fail;
21886 if (arg2 == NULL) {
21887 SWIG_null_ref("wxDateTime");
21888 }
21889 if (SWIG_arg_fail(2)) SWIG_fail;
21890 }
21891 {
21892 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21893 if (SWIG_arg_fail(3)) SWIG_fail;
21894 if (arg3 == NULL) {
21895 SWIG_null_ref("wxTimeSpan");
21896 }
21897 if (SWIG_arg_fail(3)) SWIG_fail;
21898 }
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21902
21903 wxPyEndAllowThreads(__tstate);
21904 if (PyErr_Occurred()) SWIG_fail;
21905 }
21906 {
21907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21908 }
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21916 PyObject *resultobj;
21917 wxDateTime *arg1 = (wxDateTime *) 0 ;
21918 wxTimeSpan *arg2 = 0 ;
21919 wxDateTime *result;
21920 PyObject * obj0 = 0 ;
21921 PyObject * obj1 = 0 ;
21922 char *kwnames[] = {
21923 (char *) "self",(char *) "diff", NULL
21924 };
21925
21926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21928 if (SWIG_arg_fail(1)) SWIG_fail;
21929 {
21930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21931 if (SWIG_arg_fail(2)) SWIG_fail;
21932 if (arg2 == NULL) {
21933 SWIG_null_ref("wxTimeSpan");
21934 }
21935 if (SWIG_arg_fail(2)) SWIG_fail;
21936 }
21937 {
21938 PyThreadState* __tstate = wxPyBeginAllowThreads();
21939 {
21940 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21941 result = (wxDateTime *) &_result_ref;
21942 }
21943
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj;
21956 wxDateTime *arg1 = (wxDateTime *) 0 ;
21957 wxDateSpan *arg2 = 0 ;
21958 wxDateTime *result;
21959 PyObject * obj0 = 0 ;
21960 PyObject * obj1 = 0 ;
21961 char *kwnames[] = {
21962 (char *) "self",(char *) "diff", NULL
21963 };
21964
21965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21967 if (SWIG_arg_fail(1)) SWIG_fail;
21968 {
21969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21970 if (SWIG_arg_fail(2)) SWIG_fail;
21971 if (arg2 == NULL) {
21972 SWIG_null_ref("wxDateSpan");
21973 }
21974 if (SWIG_arg_fail(2)) SWIG_fail;
21975 }
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 {
21979 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21980 result = (wxDateTime *) &_result_ref;
21981 }
21982
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21994 PyObject *resultobj;
21995 wxDateTime *arg1 = (wxDateTime *) 0 ;
21996 wxTimeSpan *arg2 = 0 ;
21997 wxDateTime *result;
21998 PyObject * obj0 = 0 ;
21999 PyObject * obj1 = 0 ;
22000 char *kwnames[] = {
22001 (char *) "self",(char *) "diff", NULL
22002 };
22003
22004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22006 if (SWIG_arg_fail(1)) SWIG_fail;
22007 {
22008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22009 if (SWIG_arg_fail(2)) SWIG_fail;
22010 if (arg2 == NULL) {
22011 SWIG_null_ref("wxTimeSpan");
22012 }
22013 if (SWIG_arg_fail(2)) SWIG_fail;
22014 }
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 {
22018 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22019 result = (wxDateTime *) &_result_ref;
22020 }
22021
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj;
22034 wxDateTime *arg1 = (wxDateTime *) 0 ;
22035 wxDateSpan *arg2 = 0 ;
22036 wxDateTime *result;
22037 PyObject * obj0 = 0 ;
22038 PyObject * obj1 = 0 ;
22039 char *kwnames[] = {
22040 (char *) "self",(char *) "diff", NULL
22041 };
22042
22043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22045 if (SWIG_arg_fail(1)) SWIG_fail;
22046 {
22047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22048 if (SWIG_arg_fail(2)) SWIG_fail;
22049 if (arg2 == NULL) {
22050 SWIG_null_ref("wxDateSpan");
22051 }
22052 if (SWIG_arg_fail(2)) SWIG_fail;
22053 }
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 {
22057 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22058 result = (wxDateTime *) &_result_ref;
22059 }
22060
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22072 PyObject *resultobj;
22073 wxDateTime *arg1 = (wxDateTime *) 0 ;
22074 wxDateTime *arg2 = 0 ;
22075 wxTimeSpan result;
22076 PyObject * obj0 = 0 ;
22077 PyObject * obj1 = 0 ;
22078 char *kwnames[] = {
22079 (char *) "self",(char *) "dt", NULL
22080 };
22081
22082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22084 if (SWIG_arg_fail(1)) SWIG_fail;
22085 {
22086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22087 if (SWIG_arg_fail(2)) SWIG_fail;
22088 if (arg2 == NULL) {
22089 SWIG_null_ref("wxDateTime");
22090 }
22091 if (SWIG_arg_fail(2)) SWIG_fail;
22092 }
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22096
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 wxTimeSpan * resultptr;
22102 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22104 }
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22112 PyObject *resultobj;
22113 wxDateTime *arg1 = (wxDateTime *) 0 ;
22114 wxTimeSpan *arg2 = 0 ;
22115 wxDateTime *result;
22116 PyObject * obj0 = 0 ;
22117 PyObject * obj1 = 0 ;
22118
22119 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22121 if (SWIG_arg_fail(1)) SWIG_fail;
22122 {
22123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22124 if (SWIG_arg_fail(2)) SWIG_fail;
22125 if (arg2 == NULL) {
22126 SWIG_null_ref("wxTimeSpan");
22127 }
22128 if (SWIG_arg_fail(2)) SWIG_fail;
22129 }
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 {
22133 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22134 result = (wxDateTime *) &_result_ref;
22135 }
22136
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22148 PyObject *resultobj;
22149 wxDateTime *arg1 = (wxDateTime *) 0 ;
22150 wxDateSpan *arg2 = 0 ;
22151 wxDateTime *result;
22152 PyObject * obj0 = 0 ;
22153 PyObject * obj1 = 0 ;
22154
22155 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22157 if (SWIG_arg_fail(1)) SWIG_fail;
22158 {
22159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22160 if (SWIG_arg_fail(2)) SWIG_fail;
22161 if (arg2 == NULL) {
22162 SWIG_null_ref("wxDateSpan");
22163 }
22164 if (SWIG_arg_fail(2)) SWIG_fail;
22165 }
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 {
22169 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22170 result = (wxDateTime *) &_result_ref;
22171 }
22172
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22184 int argc;
22185 PyObject *argv[3];
22186 int ii;
22187
22188 argc = PyObject_Length(args);
22189 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22190 argv[ii] = PyTuple_GetItem(args,ii);
22191 }
22192 if (argc == 2) {
22193 int _v;
22194 {
22195 void *ptr;
22196 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22197 _v = 0;
22198 PyErr_Clear();
22199 } else {
22200 _v = 1;
22201 }
22202 }
22203 if (_v) {
22204 {
22205 void *ptr = 0;
22206 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22207 _v = 0;
22208 PyErr_Clear();
22209 } else {
22210 _v = (ptr != 0);
22211 }
22212 }
22213 if (_v) {
22214 return _wrap_DateTime___iadd____SWIG_0(self,args);
22215 }
22216 }
22217 }
22218 if (argc == 2) {
22219 int _v;
22220 {
22221 void *ptr;
22222 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22223 _v = 0;
22224 PyErr_Clear();
22225 } else {
22226 _v = 1;
22227 }
22228 }
22229 if (_v) {
22230 {
22231 void *ptr = 0;
22232 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22233 _v = 0;
22234 PyErr_Clear();
22235 } else {
22236 _v = (ptr != 0);
22237 }
22238 }
22239 if (_v) {
22240 return _wrap_DateTime___iadd____SWIG_1(self,args);
22241 }
22242 }
22243 }
22244
22245 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22246 return NULL;
22247 }
22248
22249
22250 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22251 PyObject *resultobj;
22252 wxDateTime *arg1 = (wxDateTime *) 0 ;
22253 wxTimeSpan *arg2 = 0 ;
22254 wxDateTime *result;
22255 PyObject * obj0 = 0 ;
22256 PyObject * obj1 = 0 ;
22257
22258 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 {
22262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22263 if (SWIG_arg_fail(2)) SWIG_fail;
22264 if (arg2 == NULL) {
22265 SWIG_null_ref("wxTimeSpan");
22266 }
22267 if (SWIG_arg_fail(2)) SWIG_fail;
22268 }
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 {
22272 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22273 result = (wxDateTime *) &_result_ref;
22274 }
22275
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22287 PyObject *resultobj;
22288 wxDateTime *arg1 = (wxDateTime *) 0 ;
22289 wxDateSpan *arg2 = 0 ;
22290 wxDateTime *result;
22291 PyObject * obj0 = 0 ;
22292 PyObject * obj1 = 0 ;
22293
22294 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 {
22298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22299 if (SWIG_arg_fail(2)) SWIG_fail;
22300 if (arg2 == NULL) {
22301 SWIG_null_ref("wxDateSpan");
22302 }
22303 if (SWIG_arg_fail(2)) SWIG_fail;
22304 }
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 {
22308 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22309 result = (wxDateTime *) &_result_ref;
22310 }
22311
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22323 int argc;
22324 PyObject *argv[3];
22325 int ii;
22326
22327 argc = PyObject_Length(args);
22328 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22329 argv[ii] = PyTuple_GetItem(args,ii);
22330 }
22331 if (argc == 2) {
22332 int _v;
22333 {
22334 void *ptr;
22335 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22336 _v = 0;
22337 PyErr_Clear();
22338 } else {
22339 _v = 1;
22340 }
22341 }
22342 if (_v) {
22343 {
22344 void *ptr = 0;
22345 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22346 _v = 0;
22347 PyErr_Clear();
22348 } else {
22349 _v = (ptr != 0);
22350 }
22351 }
22352 if (_v) {
22353 return _wrap_DateTime___isub____SWIG_0(self,args);
22354 }
22355 }
22356 }
22357 if (argc == 2) {
22358 int _v;
22359 {
22360 void *ptr;
22361 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22362 _v = 0;
22363 PyErr_Clear();
22364 } else {
22365 _v = 1;
22366 }
22367 }
22368 if (_v) {
22369 {
22370 void *ptr = 0;
22371 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22372 _v = 0;
22373 PyErr_Clear();
22374 } else {
22375 _v = (ptr != 0);
22376 }
22377 }
22378 if (_v) {
22379 return _wrap_DateTime___isub____SWIG_1(self,args);
22380 }
22381 }
22382 }
22383
22384 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22385 return NULL;
22386 }
22387
22388
22389 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22390 PyObject *resultobj;
22391 wxDateTime *arg1 = (wxDateTime *) 0 ;
22392 wxTimeSpan *arg2 = 0 ;
22393 wxDateTime result;
22394 PyObject * obj0 = 0 ;
22395 PyObject * obj1 = 0 ;
22396
22397 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22399 if (SWIG_arg_fail(1)) SWIG_fail;
22400 {
22401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(2)) SWIG_fail;
22403 if (arg2 == NULL) {
22404 SWIG_null_ref("wxTimeSpan");
22405 }
22406 if (SWIG_arg_fail(2)) SWIG_fail;
22407 }
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22411
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 {
22416 wxDateTime * resultptr;
22417 resultptr = new wxDateTime((wxDateTime &)(result));
22418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22419 }
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22427 PyObject *resultobj;
22428 wxDateTime *arg1 = (wxDateTime *) 0 ;
22429 wxDateSpan *arg2 = 0 ;
22430 wxDateTime result;
22431 PyObject * obj0 = 0 ;
22432 PyObject * obj1 = 0 ;
22433
22434 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22436 if (SWIG_arg_fail(1)) SWIG_fail;
22437 {
22438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(2)) SWIG_fail;
22440 if (arg2 == NULL) {
22441 SWIG_null_ref("wxDateSpan");
22442 }
22443 if (SWIG_arg_fail(2)) SWIG_fail;
22444 }
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 {
22453 wxDateTime * resultptr;
22454 resultptr = new wxDateTime((wxDateTime &)(result));
22455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22456 }
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22464 int argc;
22465 PyObject *argv[3];
22466 int ii;
22467
22468 argc = PyObject_Length(args);
22469 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22470 argv[ii] = PyTuple_GetItem(args,ii);
22471 }
22472 if (argc == 2) {
22473 int _v;
22474 {
22475 void *ptr;
22476 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22477 _v = 0;
22478 PyErr_Clear();
22479 } else {
22480 _v = 1;
22481 }
22482 }
22483 if (_v) {
22484 {
22485 void *ptr = 0;
22486 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22487 _v = 0;
22488 PyErr_Clear();
22489 } else {
22490 _v = (ptr != 0);
22491 }
22492 }
22493 if (_v) {
22494 return _wrap_DateTime___add____SWIG_0(self,args);
22495 }
22496 }
22497 }
22498 if (argc == 2) {
22499 int _v;
22500 {
22501 void *ptr;
22502 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22503 _v = 0;
22504 PyErr_Clear();
22505 } else {
22506 _v = 1;
22507 }
22508 }
22509 if (_v) {
22510 {
22511 void *ptr = 0;
22512 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22513 _v = 0;
22514 PyErr_Clear();
22515 } else {
22516 _v = (ptr != 0);
22517 }
22518 }
22519 if (_v) {
22520 return _wrap_DateTime___add____SWIG_1(self,args);
22521 }
22522 }
22523 }
22524
22525 Py_INCREF(Py_NotImplemented);
22526 return Py_NotImplemented;
22527 }
22528
22529
22530 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22531 PyObject *resultobj;
22532 wxDateTime *arg1 = (wxDateTime *) 0 ;
22533 wxDateTime *arg2 = 0 ;
22534 wxTimeSpan result;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537
22538 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22540 if (SWIG_arg_fail(1)) SWIG_fail;
22541 {
22542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(2)) SWIG_fail;
22544 if (arg2 == NULL) {
22545 SWIG_null_ref("wxDateTime");
22546 }
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 }
22549 {
22550 PyThreadState* __tstate = wxPyBeginAllowThreads();
22551 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22552
22553 wxPyEndAllowThreads(__tstate);
22554 if (PyErr_Occurred()) SWIG_fail;
22555 }
22556 {
22557 wxTimeSpan * resultptr;
22558 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22560 }
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22568 PyObject *resultobj;
22569 wxDateTime *arg1 = (wxDateTime *) 0 ;
22570 wxTimeSpan *arg2 = 0 ;
22571 wxDateTime result;
22572 PyObject * obj0 = 0 ;
22573 PyObject * obj1 = 0 ;
22574
22575 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22577 if (SWIG_arg_fail(1)) SWIG_fail;
22578 {
22579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22580 if (SWIG_arg_fail(2)) SWIG_fail;
22581 if (arg2 == NULL) {
22582 SWIG_null_ref("wxTimeSpan");
22583 }
22584 if (SWIG_arg_fail(2)) SWIG_fail;
22585 }
22586 {
22587 PyThreadState* __tstate = wxPyBeginAllowThreads();
22588 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22589
22590 wxPyEndAllowThreads(__tstate);
22591 if (PyErr_Occurred()) SWIG_fail;
22592 }
22593 {
22594 wxDateTime * resultptr;
22595 resultptr = new wxDateTime((wxDateTime &)(result));
22596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22597 }
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22605 PyObject *resultobj;
22606 wxDateTime *arg1 = (wxDateTime *) 0 ;
22607 wxDateSpan *arg2 = 0 ;
22608 wxDateTime result;
22609 PyObject * obj0 = 0 ;
22610 PyObject * obj1 = 0 ;
22611
22612 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22614 if (SWIG_arg_fail(1)) SWIG_fail;
22615 {
22616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22617 if (SWIG_arg_fail(2)) SWIG_fail;
22618 if (arg2 == NULL) {
22619 SWIG_null_ref("wxDateSpan");
22620 }
22621 if (SWIG_arg_fail(2)) SWIG_fail;
22622 }
22623 {
22624 PyThreadState* __tstate = wxPyBeginAllowThreads();
22625 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22626
22627 wxPyEndAllowThreads(__tstate);
22628 if (PyErr_Occurred()) SWIG_fail;
22629 }
22630 {
22631 wxDateTime * resultptr;
22632 resultptr = new wxDateTime((wxDateTime &)(result));
22633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22634 }
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22642 int argc;
22643 PyObject *argv[3];
22644 int ii;
22645
22646 argc = PyObject_Length(args);
22647 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22648 argv[ii] = PyTuple_GetItem(args,ii);
22649 }
22650 if (argc == 2) {
22651 int _v;
22652 {
22653 void *ptr;
22654 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22655 _v = 0;
22656 PyErr_Clear();
22657 } else {
22658 _v = 1;
22659 }
22660 }
22661 if (_v) {
22662 {
22663 void *ptr = 0;
22664 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22665 _v = 0;
22666 PyErr_Clear();
22667 } else {
22668 _v = (ptr != 0);
22669 }
22670 }
22671 if (_v) {
22672 return _wrap_DateTime___sub____SWIG_0(self,args);
22673 }
22674 }
22675 }
22676 if (argc == 2) {
22677 int _v;
22678 {
22679 void *ptr;
22680 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22681 _v = 0;
22682 PyErr_Clear();
22683 } else {
22684 _v = 1;
22685 }
22686 }
22687 if (_v) {
22688 {
22689 void *ptr = 0;
22690 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22691 _v = 0;
22692 PyErr_Clear();
22693 } else {
22694 _v = (ptr != 0);
22695 }
22696 }
22697 if (_v) {
22698 return _wrap_DateTime___sub____SWIG_1(self,args);
22699 }
22700 }
22701 }
22702 if (argc == 2) {
22703 int _v;
22704 {
22705 void *ptr;
22706 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22707 _v = 0;
22708 PyErr_Clear();
22709 } else {
22710 _v = 1;
22711 }
22712 }
22713 if (_v) {
22714 {
22715 void *ptr = 0;
22716 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22717 _v = 0;
22718 PyErr_Clear();
22719 } else {
22720 _v = (ptr != 0);
22721 }
22722 }
22723 if (_v) {
22724 return _wrap_DateTime___sub____SWIG_2(self,args);
22725 }
22726 }
22727 }
22728
22729 Py_INCREF(Py_NotImplemented);
22730 return Py_NotImplemented;
22731 }
22732
22733
22734 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22735 PyObject *resultobj;
22736 wxDateTime *arg1 = (wxDateTime *) 0 ;
22737 wxDateTime *arg2 = (wxDateTime *) 0 ;
22738 bool result;
22739 PyObject * obj0 = 0 ;
22740 PyObject * obj1 = 0 ;
22741 char *kwnames[] = {
22742 (char *) "self",(char *) "other", NULL
22743 };
22744
22745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22747 if (SWIG_arg_fail(1)) SWIG_fail;
22748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22749 if (SWIG_arg_fail(2)) SWIG_fail;
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22753
22754 wxPyEndAllowThreads(__tstate);
22755 if (PyErr_Occurred()) SWIG_fail;
22756 }
22757 {
22758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22759 }
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22767 PyObject *resultobj;
22768 wxDateTime *arg1 = (wxDateTime *) 0 ;
22769 wxDateTime *arg2 = (wxDateTime *) 0 ;
22770 bool result;
22771 PyObject * obj0 = 0 ;
22772 PyObject * obj1 = 0 ;
22773 char *kwnames[] = {
22774 (char *) "self",(char *) "other", NULL
22775 };
22776
22777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
22778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22779 if (SWIG_arg_fail(1)) SWIG_fail;
22780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22781 if (SWIG_arg_fail(2)) SWIG_fail;
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22785
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 {
22790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22791 }
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj;
22800 wxDateTime *arg1 = (wxDateTime *) 0 ;
22801 wxDateTime *arg2 = (wxDateTime *) 0 ;
22802 bool result;
22803 PyObject * obj0 = 0 ;
22804 PyObject * obj1 = 0 ;
22805 char *kwnames[] = {
22806 (char *) "self",(char *) "other", NULL
22807 };
22808
22809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22811 if (SWIG_arg_fail(1)) SWIG_fail;
22812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22813 if (SWIG_arg_fail(2)) SWIG_fail;
22814 {
22815 PyThreadState* __tstate = wxPyBeginAllowThreads();
22816 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22817
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 {
22822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22823 }
22824 return resultobj;
22825 fail:
22826 return NULL;
22827 }
22828
22829
22830 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22831 PyObject *resultobj;
22832 wxDateTime *arg1 = (wxDateTime *) 0 ;
22833 wxDateTime *arg2 = (wxDateTime *) 0 ;
22834 bool result;
22835 PyObject * obj0 = 0 ;
22836 PyObject * obj1 = 0 ;
22837 char *kwnames[] = {
22838 (char *) "self",(char *) "other", NULL
22839 };
22840
22841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22843 if (SWIG_arg_fail(1)) SWIG_fail;
22844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22845 if (SWIG_arg_fail(2)) SWIG_fail;
22846 {
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22849
22850 wxPyEndAllowThreads(__tstate);
22851 if (PyErr_Occurred()) SWIG_fail;
22852 }
22853 {
22854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22855 }
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22863 PyObject *resultobj;
22864 wxDateTime *arg1 = (wxDateTime *) 0 ;
22865 wxDateTime *arg2 = (wxDateTime *) 0 ;
22866 bool result;
22867 PyObject * obj0 = 0 ;
22868 PyObject * obj1 = 0 ;
22869 char *kwnames[] = {
22870 (char *) "self",(char *) "other", NULL
22871 };
22872
22873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22875 if (SWIG_arg_fail(1)) SWIG_fail;
22876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22877 if (SWIG_arg_fail(2)) SWIG_fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22881
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 {
22886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22887 }
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj;
22896 wxDateTime *arg1 = (wxDateTime *) 0 ;
22897 wxDateTime *arg2 = (wxDateTime *) 0 ;
22898 bool result;
22899 PyObject * obj0 = 0 ;
22900 PyObject * obj1 = 0 ;
22901 char *kwnames[] = {
22902 (char *) "self",(char *) "other", NULL
22903 };
22904
22905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22907 if (SWIG_arg_fail(1)) SWIG_fail;
22908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22909 if (SWIG_arg_fail(2)) SWIG_fail;
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22913
22914 wxPyEndAllowThreads(__tstate);
22915 if (PyErr_Occurred()) SWIG_fail;
22916 }
22917 {
22918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22919 }
22920 return resultobj;
22921 fail:
22922 return NULL;
22923 }
22924
22925
22926 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22927 PyObject *resultobj;
22928 wxDateTime *arg1 = (wxDateTime *) 0 ;
22929 wxString *arg2 = 0 ;
22930 int result;
22931 bool temp2 = false ;
22932 PyObject * obj0 = 0 ;
22933 PyObject * obj1 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self",(char *) "date", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(1)) SWIG_fail;
22941 {
22942 arg2 = wxString_in_helper(obj1);
22943 if (arg2 == NULL) SWIG_fail;
22944 temp2 = true;
22945 }
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 {
22954 resultobj = SWIG_From_int((int)(result));
22955 }
22956 {
22957 if (temp2)
22958 delete arg2;
22959 }
22960 return resultobj;
22961 fail:
22962 {
22963 if (temp2)
22964 delete arg2;
22965 }
22966 return NULL;
22967 }
22968
22969
22970 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22971 PyObject *resultobj;
22972 wxDateTime *arg1 = (wxDateTime *) 0 ;
22973 wxString *arg2 = 0 ;
22974 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22975 wxString *arg3 = (wxString *) &arg3_defvalue ;
22976 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22977 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22978 int result;
22979 bool temp2 = false ;
22980 bool temp3 = false ;
22981 PyObject * obj0 = 0 ;
22982 PyObject * obj1 = 0 ;
22983 PyObject * obj2 = 0 ;
22984 PyObject * obj3 = 0 ;
22985 char *kwnames[] = {
22986 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22987 };
22988
22989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22991 if (SWIG_arg_fail(1)) SWIG_fail;
22992 {
22993 arg2 = wxString_in_helper(obj1);
22994 if (arg2 == NULL) SWIG_fail;
22995 temp2 = true;
22996 }
22997 if (obj2) {
22998 {
22999 arg3 = wxString_in_helper(obj2);
23000 if (arg3 == NULL) SWIG_fail;
23001 temp3 = true;
23002 }
23003 }
23004 if (obj3) {
23005 {
23006 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23007 if (SWIG_arg_fail(4)) SWIG_fail;
23008 if (arg4 == NULL) {
23009 SWIG_null_ref("wxDateTime");
23010 }
23011 if (SWIG_arg_fail(4)) SWIG_fail;
23012 }
23013 }
23014 {
23015 PyThreadState* __tstate = wxPyBeginAllowThreads();
23016 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23017
23018 wxPyEndAllowThreads(__tstate);
23019 if (PyErr_Occurred()) SWIG_fail;
23020 }
23021 {
23022 resultobj = SWIG_From_int((int)(result));
23023 }
23024 {
23025 if (temp2)
23026 delete arg2;
23027 }
23028 {
23029 if (temp3)
23030 delete arg3;
23031 }
23032 return resultobj;
23033 fail:
23034 {
23035 if (temp2)
23036 delete arg2;
23037 }
23038 {
23039 if (temp3)
23040 delete arg3;
23041 }
23042 return NULL;
23043 }
23044
23045
23046 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23047 PyObject *resultobj;
23048 wxDateTime *arg1 = (wxDateTime *) 0 ;
23049 wxString *arg2 = 0 ;
23050 int result;
23051 bool temp2 = false ;
23052 PyObject * obj0 = 0 ;
23053 PyObject * obj1 = 0 ;
23054 char *kwnames[] = {
23055 (char *) "self",(char *) "datetime", NULL
23056 };
23057
23058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23060 if (SWIG_arg_fail(1)) SWIG_fail;
23061 {
23062 arg2 = wxString_in_helper(obj1);
23063 if (arg2 == NULL) SWIG_fail;
23064 temp2 = true;
23065 }
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = SWIG_From_int((int)(result));
23075 }
23076 {
23077 if (temp2)
23078 delete arg2;
23079 }
23080 return resultobj;
23081 fail:
23082 {
23083 if (temp2)
23084 delete arg2;
23085 }
23086 return NULL;
23087 }
23088
23089
23090 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj;
23092 wxDateTime *arg1 = (wxDateTime *) 0 ;
23093 wxString *arg2 = 0 ;
23094 int result;
23095 bool temp2 = false ;
23096 PyObject * obj0 = 0 ;
23097 PyObject * obj1 = 0 ;
23098 char *kwnames[] = {
23099 (char *) "self",(char *) "date", NULL
23100 };
23101
23102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23104 if (SWIG_arg_fail(1)) SWIG_fail;
23105 {
23106 arg2 = wxString_in_helper(obj1);
23107 if (arg2 == NULL) SWIG_fail;
23108 temp2 = true;
23109 }
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23113
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 {
23118 resultobj = SWIG_From_int((int)(result));
23119 }
23120 {
23121 if (temp2)
23122 delete arg2;
23123 }
23124 return resultobj;
23125 fail:
23126 {
23127 if (temp2)
23128 delete arg2;
23129 }
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 wxDateTime *arg1 = (wxDateTime *) 0 ;
23137 wxString *arg2 = 0 ;
23138 int result;
23139 bool temp2 = false ;
23140 PyObject * obj0 = 0 ;
23141 PyObject * obj1 = 0 ;
23142 char *kwnames[] = {
23143 (char *) "self",(char *) "time", NULL
23144 };
23145
23146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23148 if (SWIG_arg_fail(1)) SWIG_fail;
23149 {
23150 arg2 = wxString_in_helper(obj1);
23151 if (arg2 == NULL) SWIG_fail;
23152 temp2 = true;
23153 }
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23157
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 {
23162 resultobj = SWIG_From_int((int)(result));
23163 }
23164 {
23165 if (temp2)
23166 delete arg2;
23167 }
23168 return resultobj;
23169 fail:
23170 {
23171 if (temp2)
23172 delete arg2;
23173 }
23174 return NULL;
23175 }
23176
23177
23178 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj;
23180 wxDateTime *arg1 = (wxDateTime *) 0 ;
23181 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23182 wxString *arg2 = (wxString *) &arg2_defvalue ;
23183 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23184 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23185 wxString result;
23186 bool temp2 = false ;
23187 bool temp3 = false ;
23188 PyObject * obj0 = 0 ;
23189 PyObject * obj1 = 0 ;
23190 PyObject * obj2 = 0 ;
23191 char *kwnames[] = {
23192 (char *) "self",(char *) "format",(char *) "tz", NULL
23193 };
23194
23195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23197 if (SWIG_arg_fail(1)) SWIG_fail;
23198 if (obj1) {
23199 {
23200 arg2 = wxString_in_helper(obj1);
23201 if (arg2 == NULL) SWIG_fail;
23202 temp2 = true;
23203 }
23204 }
23205 if (obj2) {
23206 {
23207 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23208 temp3 = true;
23209 }
23210 }
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23214
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 #if wxUSE_UNICODE
23220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23221 #else
23222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23223 #endif
23224 }
23225 {
23226 if (temp2)
23227 delete arg2;
23228 }
23229 {
23230 if (temp3) delete arg3;
23231 }
23232 return resultobj;
23233 fail:
23234 {
23235 if (temp2)
23236 delete arg2;
23237 }
23238 {
23239 if (temp3) delete arg3;
23240 }
23241 return NULL;
23242 }
23243
23244
23245 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23246 PyObject *resultobj;
23247 wxDateTime *arg1 = (wxDateTime *) 0 ;
23248 wxString result;
23249 PyObject * obj0 = 0 ;
23250 char *kwnames[] = {
23251 (char *) "self", NULL
23252 };
23253
23254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(1)) SWIG_fail;
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = ((wxDateTime const *)arg1)->FormatDate();
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 #if wxUSE_UNICODE
23266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23267 #else
23268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23269 #endif
23270 }
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj;
23279 wxDateTime *arg1 = (wxDateTime *) 0 ;
23280 wxString result;
23281 PyObject * obj0 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "self", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(1)) SWIG_fail;
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 result = ((wxDateTime const *)arg1)->FormatTime();
23292
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 {
23297 #if wxUSE_UNICODE
23298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23299 #else
23300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23301 #endif
23302 }
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj;
23311 wxDateTime *arg1 = (wxDateTime *) 0 ;
23312 wxString result;
23313 PyObject * obj0 = 0 ;
23314 char *kwnames[] = {
23315 (char *) "self", NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23320 if (SWIG_arg_fail(1)) SWIG_fail;
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = ((wxDateTime const *)arg1)->FormatISODate();
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 {
23329 #if wxUSE_UNICODE
23330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23331 #else
23332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23333 #endif
23334 }
23335 return resultobj;
23336 fail:
23337 return NULL;
23338 }
23339
23340
23341 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23342 PyObject *resultobj;
23343 wxDateTime *arg1 = (wxDateTime *) 0 ;
23344 wxString result;
23345 PyObject * obj0 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(1)) SWIG_fail;
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 result = ((wxDateTime const *)arg1)->FormatISOTime();
23356
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 {
23361 #if wxUSE_UNICODE
23362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23363 #else
23364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23365 #endif
23366 }
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23374 PyObject *obj;
23375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23376 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23377 Py_INCREF(obj);
23378 return Py_BuildValue((char *)"");
23379 }
23380 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23381 PyObject *resultobj;
23382 long arg1 ;
23383 wxTimeSpan result;
23384 PyObject * obj0 = 0 ;
23385 char *kwnames[] = {
23386 (char *) "sec", NULL
23387 };
23388
23389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23390 {
23391 arg1 = (long)(SWIG_As_long(obj0));
23392 if (SWIG_arg_fail(1)) SWIG_fail;
23393 }
23394 {
23395 PyThreadState* __tstate = wxPyBeginAllowThreads();
23396 result = wxTimeSpan::Seconds(arg1);
23397
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 {
23402 wxTimeSpan * resultptr;
23403 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23405 }
23406 return resultobj;
23407 fail:
23408 return NULL;
23409 }
23410
23411
23412 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj;
23414 wxTimeSpan result;
23415 char *kwnames[] = {
23416 NULL
23417 };
23418
23419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 result = wxTimeSpan::Second();
23423
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 {
23428 wxTimeSpan * resultptr;
23429 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23431 }
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23439 PyObject *resultobj;
23440 long arg1 ;
23441 wxTimeSpan result;
23442 PyObject * obj0 = 0 ;
23443 char *kwnames[] = {
23444 (char *) "min", NULL
23445 };
23446
23447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23448 {
23449 arg1 = (long)(SWIG_As_long(obj0));
23450 if (SWIG_arg_fail(1)) SWIG_fail;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = wxTimeSpan::Minutes(arg1);
23455
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 wxTimeSpan * resultptr;
23461 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23463 }
23464 return resultobj;
23465 fail:
23466 return NULL;
23467 }
23468
23469
23470 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23471 PyObject *resultobj;
23472 wxTimeSpan result;
23473 char *kwnames[] = {
23474 NULL
23475 };
23476
23477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 result = wxTimeSpan::Minute();
23481
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 {
23486 wxTimeSpan * resultptr;
23487 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23489 }
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23497 PyObject *resultobj;
23498 long arg1 ;
23499 wxTimeSpan result;
23500 PyObject * obj0 = 0 ;
23501 char *kwnames[] = {
23502 (char *) "hours", NULL
23503 };
23504
23505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23506 {
23507 arg1 = (long)(SWIG_As_long(obj0));
23508 if (SWIG_arg_fail(1)) SWIG_fail;
23509 }
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = wxTimeSpan::Hours(arg1);
23513
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 {
23518 wxTimeSpan * resultptr;
23519 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj;
23530 wxTimeSpan result;
23531 char *kwnames[] = {
23532 NULL
23533 };
23534
23535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23536 {
23537 PyThreadState* __tstate = wxPyBeginAllowThreads();
23538 result = wxTimeSpan::Hour();
23539
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 {
23544 wxTimeSpan * resultptr;
23545 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23547 }
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23555 PyObject *resultobj;
23556 long arg1 ;
23557 wxTimeSpan result;
23558 PyObject * obj0 = 0 ;
23559 char *kwnames[] = {
23560 (char *) "days", NULL
23561 };
23562
23563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23564 {
23565 arg1 = (long)(SWIG_As_long(obj0));
23566 if (SWIG_arg_fail(1)) SWIG_fail;
23567 }
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 result = wxTimeSpan::Days(arg1);
23571
23572 wxPyEndAllowThreads(__tstate);
23573 if (PyErr_Occurred()) SWIG_fail;
23574 }
23575 {
23576 wxTimeSpan * resultptr;
23577 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23579 }
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23587 PyObject *resultobj;
23588 wxTimeSpan result;
23589 char *kwnames[] = {
23590 NULL
23591 };
23592
23593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23594 {
23595 PyThreadState* __tstate = wxPyBeginAllowThreads();
23596 result = wxTimeSpan::Day();
23597
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 {
23602 wxTimeSpan * resultptr;
23603 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23605 }
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23613 PyObject *resultobj;
23614 long arg1 ;
23615 wxTimeSpan result;
23616 PyObject * obj0 = 0 ;
23617 char *kwnames[] = {
23618 (char *) "days", NULL
23619 };
23620
23621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23622 {
23623 arg1 = (long)(SWIG_As_long(obj0));
23624 if (SWIG_arg_fail(1)) SWIG_fail;
23625 }
23626 {
23627 PyThreadState* __tstate = wxPyBeginAllowThreads();
23628 result = wxTimeSpan::Weeks(arg1);
23629
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 {
23634 wxTimeSpan * resultptr;
23635 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23637 }
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23645 PyObject *resultobj;
23646 wxTimeSpan result;
23647 char *kwnames[] = {
23648 NULL
23649 };
23650
23651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = wxTimeSpan::Week();
23655
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 {
23660 wxTimeSpan * resultptr;
23661 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23663 }
23664 return resultobj;
23665 fail:
23666 return NULL;
23667 }
23668
23669
23670 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj;
23672 long arg1 = (long) 0 ;
23673 long arg2 = (long) 0 ;
23674 long arg3 = (long) 0 ;
23675 long arg4 = (long) 0 ;
23676 wxTimeSpan *result;
23677 PyObject * obj0 = 0 ;
23678 PyObject * obj1 = 0 ;
23679 PyObject * obj2 = 0 ;
23680 PyObject * obj3 = 0 ;
23681 char *kwnames[] = {
23682 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23683 };
23684
23685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23686 if (obj0) {
23687 {
23688 arg1 = (long)(SWIG_As_long(obj0));
23689 if (SWIG_arg_fail(1)) SWIG_fail;
23690 }
23691 }
23692 if (obj1) {
23693 {
23694 arg2 = (long)(SWIG_As_long(obj1));
23695 if (SWIG_arg_fail(2)) SWIG_fail;
23696 }
23697 }
23698 if (obj2) {
23699 {
23700 arg3 = (long)(SWIG_As_long(obj2));
23701 if (SWIG_arg_fail(3)) SWIG_fail;
23702 }
23703 }
23704 if (obj3) {
23705 {
23706 arg4 = (long)(SWIG_As_long(obj3));
23707 if (SWIG_arg_fail(4)) SWIG_fail;
23708 }
23709 }
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23713
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj;
23726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23727 PyObject * obj0 = 0 ;
23728 char *kwnames[] = {
23729 (char *) "self", NULL
23730 };
23731
23732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23734 if (SWIG_arg_fail(1)) SWIG_fail;
23735 {
23736 PyThreadState* __tstate = wxPyBeginAllowThreads();
23737 delete arg1;
23738
23739 wxPyEndAllowThreads(__tstate);
23740 if (PyErr_Occurred()) SWIG_fail;
23741 }
23742 Py_INCREF(Py_None); resultobj = Py_None;
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23750 PyObject *resultobj;
23751 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23752 wxTimeSpan *arg2 = 0 ;
23753 wxTimeSpan *result;
23754 PyObject * obj0 = 0 ;
23755 PyObject * obj1 = 0 ;
23756 char *kwnames[] = {
23757 (char *) "self",(char *) "diff", NULL
23758 };
23759
23760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23762 if (SWIG_arg_fail(1)) SWIG_fail;
23763 {
23764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(2)) SWIG_fail;
23766 if (arg2 == NULL) {
23767 SWIG_null_ref("wxTimeSpan");
23768 }
23769 if (SWIG_arg_fail(2)) SWIG_fail;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 {
23774 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23775 result = (wxTimeSpan *) &_result_ref;
23776 }
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj;
23790 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23791 wxTimeSpan *arg2 = 0 ;
23792 wxTimeSpan *result;
23793 PyObject * obj0 = 0 ;
23794 PyObject * obj1 = 0 ;
23795 char *kwnames[] = {
23796 (char *) "self",(char *) "diff", NULL
23797 };
23798
23799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23801 if (SWIG_arg_fail(1)) SWIG_fail;
23802 {
23803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(2)) SWIG_fail;
23805 if (arg2 == NULL) {
23806 SWIG_null_ref("wxTimeSpan");
23807 }
23808 if (SWIG_arg_fail(2)) SWIG_fail;
23809 }
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 {
23813 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23814 result = (wxTimeSpan *) &_result_ref;
23815 }
23816
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23828 PyObject *resultobj;
23829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23830 int arg2 ;
23831 wxTimeSpan *result;
23832 PyObject * obj0 = 0 ;
23833 PyObject * obj1 = 0 ;
23834 char *kwnames[] = {
23835 (char *) "self",(char *) "n", NULL
23836 };
23837
23838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23840 if (SWIG_arg_fail(1)) SWIG_fail;
23841 {
23842 arg2 = (int)(SWIG_As_int(obj1));
23843 if (SWIG_arg_fail(2)) SWIG_fail;
23844 }
23845 {
23846 PyThreadState* __tstate = wxPyBeginAllowThreads();
23847 {
23848 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23849 result = (wxTimeSpan *) &_result_ref;
23850 }
23851
23852 wxPyEndAllowThreads(__tstate);
23853 if (PyErr_Occurred()) SWIG_fail;
23854 }
23855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23856 return resultobj;
23857 fail:
23858 return NULL;
23859 }
23860
23861
23862 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj;
23864 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23865 wxTimeSpan *result;
23866 PyObject * obj0 = 0 ;
23867 char *kwnames[] = {
23868 (char *) "self", NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23873 if (SWIG_arg_fail(1)) SWIG_fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 {
23877 wxTimeSpan &_result_ref = (arg1)->Neg();
23878 result = (wxTimeSpan *) &_result_ref;
23879 }
23880
23881 wxPyEndAllowThreads(__tstate);
23882 if (PyErr_Occurred()) SWIG_fail;
23883 }
23884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23892 PyObject *resultobj;
23893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23894 wxTimeSpan result;
23895 PyObject * obj0 = 0 ;
23896 char *kwnames[] = {
23897 (char *) "self", NULL
23898 };
23899
23900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23902 if (SWIG_arg_fail(1)) SWIG_fail;
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = ((wxTimeSpan const *)arg1)->Abs();
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 {
23911 wxTimeSpan * resultptr;
23912 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23914 }
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23922 PyObject *resultobj;
23923 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23924 wxTimeSpan *arg2 = 0 ;
23925 wxTimeSpan *result;
23926 PyObject * obj0 = 0 ;
23927 PyObject * obj1 = 0 ;
23928 char *kwnames[] = {
23929 (char *) "self",(char *) "diff", NULL
23930 };
23931
23932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23934 if (SWIG_arg_fail(1)) SWIG_fail;
23935 {
23936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23937 if (SWIG_arg_fail(2)) SWIG_fail;
23938 if (arg2 == NULL) {
23939 SWIG_null_ref("wxTimeSpan");
23940 }
23941 if (SWIG_arg_fail(2)) SWIG_fail;
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 {
23946 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23947 result = (wxTimeSpan *) &_result_ref;
23948 }
23949
23950 wxPyEndAllowThreads(__tstate);
23951 if (PyErr_Occurred()) SWIG_fail;
23952 }
23953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23963 wxTimeSpan *arg2 = 0 ;
23964 wxTimeSpan *result;
23965 PyObject * obj0 = 0 ;
23966 PyObject * obj1 = 0 ;
23967 char *kwnames[] = {
23968 (char *) "self",(char *) "diff", NULL
23969 };
23970
23971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23973 if (SWIG_arg_fail(1)) SWIG_fail;
23974 {
23975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23976 if (SWIG_arg_fail(2)) SWIG_fail;
23977 if (arg2 == NULL) {
23978 SWIG_null_ref("wxTimeSpan");
23979 }
23980 if (SWIG_arg_fail(2)) SWIG_fail;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 {
23985 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23986 result = (wxTimeSpan *) &_result_ref;
23987 }
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24002 int arg2 ;
24003 wxTimeSpan *result;
24004 PyObject * obj0 = 0 ;
24005 PyObject * obj1 = 0 ;
24006 char *kwnames[] = {
24007 (char *) "self",(char *) "n", NULL
24008 };
24009
24010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24012 if (SWIG_arg_fail(1)) SWIG_fail;
24013 {
24014 arg2 = (int)(SWIG_As_int(obj1));
24015 if (SWIG_arg_fail(2)) SWIG_fail;
24016 }
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 {
24020 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24021 result = (wxTimeSpan *) &_result_ref;
24022 }
24023
24024 wxPyEndAllowThreads(__tstate);
24025 if (PyErr_Occurred()) SWIG_fail;
24026 }
24027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj;
24036 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24037 wxTimeSpan *result;
24038 PyObject * obj0 = 0 ;
24039 char *kwnames[] = {
24040 (char *) "self", NULL
24041 };
24042
24043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24045 if (SWIG_arg_fail(1)) SWIG_fail;
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 {
24049 wxTimeSpan &_result_ref = (arg1)->operator -();
24050 result = (wxTimeSpan *) &_result_ref;
24051 }
24052
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj;
24065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24066 wxTimeSpan *arg2 = 0 ;
24067 wxTimeSpan result;
24068 PyObject * obj0 = 0 ;
24069 PyObject * obj1 = 0 ;
24070 char *kwnames[] = {
24071 (char *) "self",(char *) "other", NULL
24072 };
24073
24074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24076 if (SWIG_arg_fail(1)) SWIG_fail;
24077 {
24078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 if (arg2 == NULL) {
24081 SWIG_null_ref("wxTimeSpan");
24082 }
24083 if (SWIG_arg_fail(2)) SWIG_fail;
24084 }
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24088
24089 wxPyEndAllowThreads(__tstate);
24090 if (PyErr_Occurred()) SWIG_fail;
24091 }
24092 {
24093 wxTimeSpan * resultptr;
24094 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24096 }
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24106 wxTimeSpan *arg2 = 0 ;
24107 wxTimeSpan result;
24108 PyObject * obj0 = 0 ;
24109 PyObject * obj1 = 0 ;
24110 char *kwnames[] = {
24111 (char *) "self",(char *) "other", NULL
24112 };
24113
24114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24116 if (SWIG_arg_fail(1)) SWIG_fail;
24117 {
24118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24119 if (SWIG_arg_fail(2)) SWIG_fail;
24120 if (arg2 == NULL) {
24121 SWIG_null_ref("wxTimeSpan");
24122 }
24123 if (SWIG_arg_fail(2)) SWIG_fail;
24124 }
24125 {
24126 PyThreadState* __tstate = wxPyBeginAllowThreads();
24127 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24128
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 {
24133 wxTimeSpan * resultptr;
24134 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj;
24145 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24146 int arg2 ;
24147 wxTimeSpan result;
24148 PyObject * obj0 = 0 ;
24149 PyObject * obj1 = 0 ;
24150 char *kwnames[] = {
24151 (char *) "self",(char *) "n", NULL
24152 };
24153
24154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24156 if (SWIG_arg_fail(1)) SWIG_fail;
24157 {
24158 arg2 = (int)(SWIG_As_int(obj1));
24159 if (SWIG_arg_fail(2)) SWIG_fail;
24160 }
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = wxTimeSpan___mul__(arg1,arg2);
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 {
24169 wxTimeSpan * resultptr;
24170 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24172 }
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj;
24181 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24182 int arg2 ;
24183 wxTimeSpan result;
24184 PyObject * obj0 = 0 ;
24185 PyObject * obj1 = 0 ;
24186 char *kwnames[] = {
24187 (char *) "self",(char *) "n", NULL
24188 };
24189
24190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24192 if (SWIG_arg_fail(1)) SWIG_fail;
24193 {
24194 arg2 = (int)(SWIG_As_int(obj1));
24195 if (SWIG_arg_fail(2)) SWIG_fail;
24196 }
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 result = wxTimeSpan___rmul__(arg1,arg2);
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 wxTimeSpan * resultptr;
24206 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj;
24217 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24218 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24219 bool result;
24220 PyObject * obj0 = 0 ;
24221 PyObject * obj1 = 0 ;
24222 char *kwnames[] = {
24223 (char *) "self",(char *) "other", NULL
24224 };
24225
24226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24228 if (SWIG_arg_fail(1)) SWIG_fail;
24229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24230 if (SWIG_arg_fail(2)) SWIG_fail;
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24234
24235 wxPyEndAllowThreads(__tstate);
24236 if (PyErr_Occurred()) SWIG_fail;
24237 }
24238 {
24239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24240 }
24241 return resultobj;
24242 fail:
24243 return NULL;
24244 }
24245
24246
24247 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24248 PyObject *resultobj;
24249 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24250 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24251 bool result;
24252 PyObject * obj0 = 0 ;
24253 PyObject * obj1 = 0 ;
24254 char *kwnames[] = {
24255 (char *) "self",(char *) "other", NULL
24256 };
24257
24258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24260 if (SWIG_arg_fail(1)) SWIG_fail;
24261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24262 if (SWIG_arg_fail(2)) SWIG_fail;
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24266
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj;
24281 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24282 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24283 bool result;
24284 PyObject * obj0 = 0 ;
24285 PyObject * obj1 = 0 ;
24286 char *kwnames[] = {
24287 (char *) "self",(char *) "other", NULL
24288 };
24289
24290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24292 if (SWIG_arg_fail(1)) SWIG_fail;
24293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24294 if (SWIG_arg_fail(2)) SWIG_fail;
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24298
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24314 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24315 bool result;
24316 PyObject * obj0 = 0 ;
24317 PyObject * obj1 = 0 ;
24318 char *kwnames[] = {
24319 (char *) "self",(char *) "other", NULL
24320 };
24321
24322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24324 if (SWIG_arg_fail(1)) SWIG_fail;
24325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 {
24328 PyThreadState* __tstate = wxPyBeginAllowThreads();
24329 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24330
24331 wxPyEndAllowThreads(__tstate);
24332 if (PyErr_Occurred()) SWIG_fail;
24333 }
24334 {
24335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24336 }
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24344 PyObject *resultobj;
24345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24346 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24347 bool result;
24348 PyObject * obj0 = 0 ;
24349 PyObject * obj1 = 0 ;
24350 char *kwnames[] = {
24351 (char *) "self",(char *) "other", NULL
24352 };
24353
24354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24356 if (SWIG_arg_fail(1)) SWIG_fail;
24357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24358 if (SWIG_arg_fail(2)) SWIG_fail;
24359 {
24360 PyThreadState* __tstate = wxPyBeginAllowThreads();
24361 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24362
24363 wxPyEndAllowThreads(__tstate);
24364 if (PyErr_Occurred()) SWIG_fail;
24365 }
24366 {
24367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24368 }
24369 return resultobj;
24370 fail:
24371 return NULL;
24372 }
24373
24374
24375 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24376 PyObject *resultobj;
24377 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24378 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24379 bool result;
24380 PyObject * obj0 = 0 ;
24381 PyObject * obj1 = 0 ;
24382 char *kwnames[] = {
24383 (char *) "self",(char *) "other", NULL
24384 };
24385
24386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24390 if (SWIG_arg_fail(2)) SWIG_fail;
24391 {
24392 PyThreadState* __tstate = wxPyBeginAllowThreads();
24393 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24394
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 {
24399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24400 }
24401 return resultobj;
24402 fail:
24403 return NULL;
24404 }
24405
24406
24407 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj;
24409 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24410 bool result;
24411 PyObject * obj0 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24422
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 {
24427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24428 }
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24436 PyObject *resultobj;
24437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24438 bool result;
24439 PyObject * obj0 = 0 ;
24440 char *kwnames[] = {
24441 (char *) "self", NULL
24442 };
24443
24444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24446 if (SWIG_arg_fail(1)) SWIG_fail;
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24450
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 {
24455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24456 }
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24466 bool result;
24467 PyObject * obj0 = 0 ;
24468 char *kwnames[] = {
24469 (char *) "self", NULL
24470 };
24471
24472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(1)) SWIG_fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj;
24493 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24494 wxTimeSpan *arg2 = 0 ;
24495 bool result;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "ts", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 {
24506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 if (arg2 == NULL) {
24509 SWIG_null_ref("wxTimeSpan");
24510 }
24511 if (SWIG_arg_fail(2)) SWIG_fail;
24512 }
24513 {
24514 PyThreadState* __tstate = wxPyBeginAllowThreads();
24515 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24516
24517 wxPyEndAllowThreads(__tstate);
24518 if (PyErr_Occurred()) SWIG_fail;
24519 }
24520 {
24521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24522 }
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24530 PyObject *resultobj;
24531 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24532 wxTimeSpan *arg2 = 0 ;
24533 bool result;
24534 PyObject * obj0 = 0 ;
24535 PyObject * obj1 = 0 ;
24536 char *kwnames[] = {
24537 (char *) "self",(char *) "ts", NULL
24538 };
24539
24540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24542 if (SWIG_arg_fail(1)) SWIG_fail;
24543 {
24544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24545 if (SWIG_arg_fail(2)) SWIG_fail;
24546 if (arg2 == NULL) {
24547 SWIG_null_ref("wxTimeSpan");
24548 }
24549 if (SWIG_arg_fail(2)) SWIG_fail;
24550 }
24551 {
24552 PyThreadState* __tstate = wxPyBeginAllowThreads();
24553 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24554
24555 wxPyEndAllowThreads(__tstate);
24556 if (PyErr_Occurred()) SWIG_fail;
24557 }
24558 {
24559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24560 }
24561 return resultobj;
24562 fail:
24563 return NULL;
24564 }
24565
24566
24567 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24568 PyObject *resultobj;
24569 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24570 wxTimeSpan *arg2 = 0 ;
24571 bool result;
24572 PyObject * obj0 = 0 ;
24573 PyObject * obj1 = 0 ;
24574 char *kwnames[] = {
24575 (char *) "self",(char *) "t", NULL
24576 };
24577
24578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24580 if (SWIG_arg_fail(1)) SWIG_fail;
24581 {
24582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24583 if (SWIG_arg_fail(2)) SWIG_fail;
24584 if (arg2 == NULL) {
24585 SWIG_null_ref("wxTimeSpan");
24586 }
24587 if (SWIG_arg_fail(2)) SWIG_fail;
24588 }
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24592
24593 wxPyEndAllowThreads(__tstate);
24594 if (PyErr_Occurred()) SWIG_fail;
24595 }
24596 {
24597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24598 }
24599 return resultobj;
24600 fail:
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj;
24607 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24608 int result;
24609 PyObject * obj0 = 0 ;
24610 char *kwnames[] = {
24611 (char *) "self", NULL
24612 };
24613
24614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24616 if (SWIG_arg_fail(1)) SWIG_fail;
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24620
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 {
24625 resultobj = SWIG_From_int((int)(result));
24626 }
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj;
24635 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24636 int result;
24637 PyObject * obj0 = 0 ;
24638 char *kwnames[] = {
24639 (char *) "self", NULL
24640 };
24641
24642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24644 if (SWIG_arg_fail(1)) SWIG_fail;
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24648
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 {
24653 resultobj = SWIG_From_int((int)(result));
24654 }
24655 return resultobj;
24656 fail:
24657 return NULL;
24658 }
24659
24660
24661 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24662 PyObject *resultobj;
24663 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24664 int result;
24665 PyObject * obj0 = 0 ;
24666 char *kwnames[] = {
24667 (char *) "self", NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24672 if (SWIG_arg_fail(1)) SWIG_fail;
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24676
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 {
24681 resultobj = SWIG_From_int((int)(result));
24682 }
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj;
24691 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24692 int result;
24693 PyObject * obj0 = 0 ;
24694 char *kwnames[] = {
24695 (char *) "self", NULL
24696 };
24697
24698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24700 if (SWIG_arg_fail(1)) SWIG_fail;
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24704
24705 wxPyEndAllowThreads(__tstate);
24706 if (PyErr_Occurred()) SWIG_fail;
24707 }
24708 {
24709 resultobj = SWIG_From_int((int)(result));
24710 }
24711 return resultobj;
24712 fail:
24713 return NULL;
24714 }
24715
24716
24717 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24718 PyObject *resultobj;
24719 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24720 wxLongLong result;
24721 PyObject * obj0 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) 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 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24732
24733 wxPyEndAllowThreads(__tstate);
24734 if (PyErr_Occurred()) SWIG_fail;
24735 }
24736 {
24737 PyObject *hi, *lo, *shifter, *shifted;
24738 hi = PyLong_FromLong( (&result)->GetHi() );
24739 lo = PyLong_FromLong( (&result)->GetLo() );
24740 shifter = PyLong_FromLong(32);
24741 shifted = PyNumber_Lshift(hi, shifter);
24742 resultobj = PyNumber_Or(shifted, lo);
24743 Py_DECREF(hi);
24744 Py_DECREF(lo);
24745 Py_DECREF(shifter);
24746 Py_DECREF(shifted);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24755 PyObject *resultobj;
24756 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24757 wxLongLong result;
24758 PyObject * obj0 = 0 ;
24759 char *kwnames[] = {
24760 (char *) "self", NULL
24761 };
24762
24763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24765 if (SWIG_arg_fail(1)) SWIG_fail;
24766 {
24767 PyThreadState* __tstate = wxPyBeginAllowThreads();
24768 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24769
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 PyObject *hi, *lo, *shifter, *shifted;
24775 hi = PyLong_FromLong( (&result)->GetHi() );
24776 lo = PyLong_FromLong( (&result)->GetLo() );
24777 shifter = PyLong_FromLong(32);
24778 shifted = PyNumber_Lshift(hi, shifter);
24779 resultobj = PyNumber_Or(shifted, lo);
24780 Py_DECREF(hi);
24781 Py_DECREF(lo);
24782 Py_DECREF(shifter);
24783 Py_DECREF(shifted);
24784 }
24785 return resultobj;
24786 fail:
24787 return NULL;
24788 }
24789
24790
24791 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24792 PyObject *resultobj;
24793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24794 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24795 wxString *arg2 = (wxString *) &arg2_defvalue ;
24796 wxString result;
24797 bool temp2 = false ;
24798 PyObject * obj0 = 0 ;
24799 PyObject * obj1 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self",(char *) "format", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 if (obj1) {
24808 {
24809 arg2 = wxString_in_helper(obj1);
24810 if (arg2 == NULL) SWIG_fail;
24811 temp2 = true;
24812 }
24813 }
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24817
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 {
24822 #if wxUSE_UNICODE
24823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24824 #else
24825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24826 #endif
24827 }
24828 {
24829 if (temp2)
24830 delete arg2;
24831 }
24832 return resultobj;
24833 fail:
24834 {
24835 if (temp2)
24836 delete arg2;
24837 }
24838 return NULL;
24839 }
24840
24841
24842 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24843 PyObject *obj;
24844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24845 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24846 Py_INCREF(obj);
24847 return Py_BuildValue((char *)"");
24848 }
24849 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24850 PyObject *resultobj;
24851 int arg1 = (int) 0 ;
24852 int arg2 = (int) 0 ;
24853 int arg3 = (int) 0 ;
24854 int arg4 = (int) 0 ;
24855 wxDateSpan *result;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 PyObject * obj2 = 0 ;
24859 PyObject * obj3 = 0 ;
24860 char *kwnames[] = {
24861 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24865 if (obj0) {
24866 {
24867 arg1 = (int)(SWIG_As_int(obj0));
24868 if (SWIG_arg_fail(1)) SWIG_fail;
24869 }
24870 }
24871 if (obj1) {
24872 {
24873 arg2 = (int)(SWIG_As_int(obj1));
24874 if (SWIG_arg_fail(2)) SWIG_fail;
24875 }
24876 }
24877 if (obj2) {
24878 {
24879 arg3 = (int)(SWIG_As_int(obj2));
24880 if (SWIG_arg_fail(3)) SWIG_fail;
24881 }
24882 }
24883 if (obj3) {
24884 {
24885 arg4 = (int)(SWIG_As_int(obj3));
24886 if (SWIG_arg_fail(4)) SWIG_fail;
24887 }
24888 }
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24892
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24904 PyObject *resultobj;
24905 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24906 PyObject * obj0 = 0 ;
24907 char *kwnames[] = {
24908 (char *) "self", NULL
24909 };
24910
24911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(1)) SWIG_fail;
24914 {
24915 PyThreadState* __tstate = wxPyBeginAllowThreads();
24916 delete arg1;
24917
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 Py_INCREF(Py_None); resultobj = Py_None;
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 int arg1 ;
24931 wxDateSpan result;
24932 PyObject * obj0 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "days", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24938 {
24939 arg1 = (int)(SWIG_As_int(obj0));
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 }
24942 {
24943 PyThreadState* __tstate = wxPyBeginAllowThreads();
24944 result = wxDateSpan::Days(arg1);
24945
24946 wxPyEndAllowThreads(__tstate);
24947 if (PyErr_Occurred()) SWIG_fail;
24948 }
24949 {
24950 wxDateSpan * resultptr;
24951 resultptr = new wxDateSpan((wxDateSpan &)(result));
24952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24953 }
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24961 PyObject *resultobj;
24962 wxDateSpan result;
24963 char *kwnames[] = {
24964 NULL
24965 };
24966
24967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = wxDateSpan::Day();
24971
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 wxDateSpan * resultptr;
24977 resultptr = new wxDateSpan((wxDateSpan &)(result));
24978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24979 }
24980 return resultobj;
24981 fail:
24982 return NULL;
24983 }
24984
24985
24986 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24987 PyObject *resultobj;
24988 int arg1 ;
24989 wxDateSpan result;
24990 PyObject * obj0 = 0 ;
24991 char *kwnames[] = {
24992 (char *) "weeks", NULL
24993 };
24994
24995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24996 {
24997 arg1 = (int)(SWIG_As_int(obj0));
24998 if (SWIG_arg_fail(1)) SWIG_fail;
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = wxDateSpan::Weeks(arg1);
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 wxDateSpan * resultptr;
25009 resultptr = new wxDateSpan((wxDateSpan &)(result));
25010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25019 PyObject *resultobj;
25020 wxDateSpan result;
25021 char *kwnames[] = {
25022 NULL
25023 };
25024
25025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = wxDateSpan::Week();
25029
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 wxDateSpan * resultptr;
25035 resultptr = new wxDateSpan((wxDateSpan &)(result));
25036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj;
25046 int arg1 ;
25047 wxDateSpan result;
25048 PyObject * obj0 = 0 ;
25049 char *kwnames[] = {
25050 (char *) "mon", NULL
25051 };
25052
25053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25054 {
25055 arg1 = (int)(SWIG_As_int(obj0));
25056 if (SWIG_arg_fail(1)) SWIG_fail;
25057 }
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = wxDateSpan::Months(arg1);
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 wxDateSpan * resultptr;
25067 resultptr = new wxDateSpan((wxDateSpan &)(result));
25068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25069 }
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25077 PyObject *resultobj;
25078 wxDateSpan result;
25079 char *kwnames[] = {
25080 NULL
25081 };
25082
25083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = wxDateSpan::Month();
25087
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 {
25092 wxDateSpan * resultptr;
25093 resultptr = new wxDateSpan((wxDateSpan &)(result));
25094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25095 }
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25103 PyObject *resultobj;
25104 int arg1 ;
25105 wxDateSpan result;
25106 PyObject * obj0 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "years", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25112 {
25113 arg1 = (int)(SWIG_As_int(obj0));
25114 if (SWIG_arg_fail(1)) SWIG_fail;
25115 }
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = wxDateSpan::Years(arg1);
25119
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 wxDateSpan * resultptr;
25125 resultptr = new wxDateSpan((wxDateSpan &)(result));
25126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25127 }
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxDateSpan result;
25137 char *kwnames[] = {
25138 NULL
25139 };
25140
25141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25142 {
25143 PyThreadState* __tstate = wxPyBeginAllowThreads();
25144 result = wxDateSpan::Year();
25145
25146 wxPyEndAllowThreads(__tstate);
25147 if (PyErr_Occurred()) SWIG_fail;
25148 }
25149 {
25150 wxDateSpan * resultptr;
25151 resultptr = new wxDateSpan((wxDateSpan &)(result));
25152 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25153 }
25154 return resultobj;
25155 fail:
25156 return NULL;
25157 }
25158
25159
25160 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj;
25162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25163 int arg2 ;
25164 wxDateSpan *result;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self",(char *) "n", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 {
25175 arg2 = (int)(SWIG_As_int(obj1));
25176 if (SWIG_arg_fail(2)) SWIG_fail;
25177 }
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 {
25181 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25182 result = (wxDateSpan *) &_result_ref;
25183 }
25184
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25198 int arg2 ;
25199 wxDateSpan *result;
25200 PyObject * obj0 = 0 ;
25201 PyObject * obj1 = 0 ;
25202 char *kwnames[] = {
25203 (char *) "self",(char *) "n", NULL
25204 };
25205
25206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25208 if (SWIG_arg_fail(1)) SWIG_fail;
25209 {
25210 arg2 = (int)(SWIG_As_int(obj1));
25211 if (SWIG_arg_fail(2)) SWIG_fail;
25212 }
25213 {
25214 PyThreadState* __tstate = wxPyBeginAllowThreads();
25215 {
25216 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25217 result = (wxDateSpan *) &_result_ref;
25218 }
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25233 int arg2 ;
25234 wxDateSpan *result;
25235 PyObject * obj0 = 0 ;
25236 PyObject * obj1 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "self",(char *) "n", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25243 if (SWIG_arg_fail(1)) SWIG_fail;
25244 {
25245 arg2 = (int)(SWIG_As_int(obj1));
25246 if (SWIG_arg_fail(2)) SWIG_fail;
25247 }
25248 {
25249 PyThreadState* __tstate = wxPyBeginAllowThreads();
25250 {
25251 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25252 result = (wxDateSpan *) &_result_ref;
25253 }
25254
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj;
25267 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25268 int arg2 ;
25269 wxDateSpan *result;
25270 PyObject * obj0 = 0 ;
25271 PyObject * obj1 = 0 ;
25272 char *kwnames[] = {
25273 (char *) "self",(char *) "n", NULL
25274 };
25275
25276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25278 if (SWIG_arg_fail(1)) SWIG_fail;
25279 {
25280 arg2 = (int)(SWIG_As_int(obj1));
25281 if (SWIG_arg_fail(2)) SWIG_fail;
25282 }
25283 {
25284 PyThreadState* __tstate = wxPyBeginAllowThreads();
25285 {
25286 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25287 result = (wxDateSpan *) &_result_ref;
25288 }
25289
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25294 return resultobj;
25295 fail:
25296 return NULL;
25297 }
25298
25299
25300 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25301 PyObject *resultobj;
25302 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25303 int result;
25304 PyObject * obj0 = 0 ;
25305 char *kwnames[] = {
25306 (char *) "self", NULL
25307 };
25308
25309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25311 if (SWIG_arg_fail(1)) SWIG_fail;
25312 {
25313 PyThreadState* __tstate = wxPyBeginAllowThreads();
25314 result = (int)((wxDateSpan const *)arg1)->GetYears();
25315
25316 wxPyEndAllowThreads(__tstate);
25317 if (PyErr_Occurred()) SWIG_fail;
25318 }
25319 {
25320 resultobj = SWIG_From_int((int)(result));
25321 }
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25329 PyObject *resultobj;
25330 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25331 int result;
25332 PyObject * obj0 = 0 ;
25333 char *kwnames[] = {
25334 (char *) "self", NULL
25335 };
25336
25337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25339 if (SWIG_arg_fail(1)) SWIG_fail;
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25343
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 {
25348 resultobj = SWIG_From_int((int)(result));
25349 }
25350 return resultobj;
25351 fail:
25352 return NULL;
25353 }
25354
25355
25356 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25357 PyObject *resultobj;
25358 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25359 int result;
25360 PyObject * obj0 = 0 ;
25361 char *kwnames[] = {
25362 (char *) "self", NULL
25363 };
25364
25365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25367 if (SWIG_arg_fail(1)) SWIG_fail;
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25371
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 {
25376 resultobj = SWIG_From_int((int)(result));
25377 }
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj;
25386 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25387 int result;
25388 PyObject * obj0 = 0 ;
25389 char *kwnames[] = {
25390 (char *) "self", NULL
25391 };
25392
25393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25395 if (SWIG_arg_fail(1)) SWIG_fail;
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 result = (int)((wxDateSpan const *)arg1)->GetDays();
25399
25400 wxPyEndAllowThreads(__tstate);
25401 if (PyErr_Occurred()) SWIG_fail;
25402 }
25403 {
25404 resultobj = SWIG_From_int((int)(result));
25405 }
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj;
25414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25415 int result;
25416 PyObject * obj0 = 0 ;
25417 char *kwnames[] = {
25418 (char *) "self", NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25423 if (SWIG_arg_fail(1)) SWIG_fail;
25424 {
25425 PyThreadState* __tstate = wxPyBeginAllowThreads();
25426 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25427
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 {
25432 resultobj = SWIG_From_int((int)(result));
25433 }
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25441 PyObject *resultobj;
25442 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25443 wxDateSpan *arg2 = 0 ;
25444 wxDateSpan *result;
25445 PyObject * obj0 = 0 ;
25446 PyObject * obj1 = 0 ;
25447 char *kwnames[] = {
25448 (char *) "self",(char *) "other", NULL
25449 };
25450
25451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25453 if (SWIG_arg_fail(1)) SWIG_fail;
25454 {
25455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25456 if (SWIG_arg_fail(2)) SWIG_fail;
25457 if (arg2 == NULL) {
25458 SWIG_null_ref("wxDateSpan");
25459 }
25460 if (SWIG_arg_fail(2)) SWIG_fail;
25461 }
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 {
25465 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25466 result = (wxDateSpan *) &_result_ref;
25467 }
25468
25469 wxPyEndAllowThreads(__tstate);
25470 if (PyErr_Occurred()) SWIG_fail;
25471 }
25472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25482 wxDateSpan *arg2 = 0 ;
25483 wxDateSpan *result;
25484 PyObject * obj0 = 0 ;
25485 PyObject * obj1 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "self",(char *) "other", NULL
25488 };
25489
25490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25492 if (SWIG_arg_fail(1)) SWIG_fail;
25493 {
25494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25495 if (SWIG_arg_fail(2)) SWIG_fail;
25496 if (arg2 == NULL) {
25497 SWIG_null_ref("wxDateSpan");
25498 }
25499 if (SWIG_arg_fail(2)) SWIG_fail;
25500 }
25501 {
25502 PyThreadState* __tstate = wxPyBeginAllowThreads();
25503 {
25504 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25505 result = (wxDateSpan *) &_result_ref;
25506 }
25507
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25519 PyObject *resultobj;
25520 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25521 wxDateSpan *result;
25522 PyObject * obj0 = 0 ;
25523 char *kwnames[] = {
25524 (char *) "self", NULL
25525 };
25526
25527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25529 if (SWIG_arg_fail(1)) SWIG_fail;
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 {
25533 wxDateSpan &_result_ref = (arg1)->Neg();
25534 result = (wxDateSpan *) &_result_ref;
25535 }
25536
25537 wxPyEndAllowThreads(__tstate);
25538 if (PyErr_Occurred()) SWIG_fail;
25539 }
25540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj;
25549 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25550 int arg2 ;
25551 wxDateSpan *result;
25552 PyObject * obj0 = 0 ;
25553 PyObject * obj1 = 0 ;
25554 char *kwnames[] = {
25555 (char *) "self",(char *) "factor", NULL
25556 };
25557
25558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25560 if (SWIG_arg_fail(1)) SWIG_fail;
25561 {
25562 arg2 = (int)(SWIG_As_int(obj1));
25563 if (SWIG_arg_fail(2)) SWIG_fail;
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 {
25568 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25569 result = (wxDateSpan *) &_result_ref;
25570 }
25571
25572 wxPyEndAllowThreads(__tstate);
25573 if (PyErr_Occurred()) SWIG_fail;
25574 }
25575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25576 return resultobj;
25577 fail:
25578 return NULL;
25579 }
25580
25581
25582 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25583 PyObject *resultobj;
25584 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25585 wxDateSpan *arg2 = 0 ;
25586 wxDateSpan *result;
25587 PyObject * obj0 = 0 ;
25588 PyObject * obj1 = 0 ;
25589 char *kwnames[] = {
25590 (char *) "self",(char *) "other", NULL
25591 };
25592
25593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25595 if (SWIG_arg_fail(1)) SWIG_fail;
25596 {
25597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25598 if (SWIG_arg_fail(2)) SWIG_fail;
25599 if (arg2 == NULL) {
25600 SWIG_null_ref("wxDateSpan");
25601 }
25602 if (SWIG_arg_fail(2)) SWIG_fail;
25603 }
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 {
25607 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25608 result = (wxDateSpan *) &_result_ref;
25609 }
25610
25611 wxPyEndAllowThreads(__tstate);
25612 if (PyErr_Occurred()) SWIG_fail;
25613 }
25614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25615 return resultobj;
25616 fail:
25617 return NULL;
25618 }
25619
25620
25621 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25622 PyObject *resultobj;
25623 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25624 wxDateSpan *arg2 = 0 ;
25625 wxDateSpan *result;
25626 PyObject * obj0 = 0 ;
25627 PyObject * obj1 = 0 ;
25628 char *kwnames[] = {
25629 (char *) "self",(char *) "other", NULL
25630 };
25631
25632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25634 if (SWIG_arg_fail(1)) SWIG_fail;
25635 {
25636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25637 if (SWIG_arg_fail(2)) SWIG_fail;
25638 if (arg2 == NULL) {
25639 SWIG_null_ref("wxDateSpan");
25640 }
25641 if (SWIG_arg_fail(2)) SWIG_fail;
25642 }
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 {
25646 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25647 result = (wxDateSpan *) &_result_ref;
25648 }
25649
25650 wxPyEndAllowThreads(__tstate);
25651 if (PyErr_Occurred()) SWIG_fail;
25652 }
25653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj;
25662 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25663 wxDateSpan *result;
25664 PyObject * obj0 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 {
25675 wxDateSpan &_result_ref = (arg1)->operator -();
25676 result = (wxDateSpan *) &_result_ref;
25677 }
25678
25679 wxPyEndAllowThreads(__tstate);
25680 if (PyErr_Occurred()) SWIG_fail;
25681 }
25682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25690 PyObject *resultobj;
25691 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25692 int arg2 ;
25693 wxDateSpan *result;
25694 PyObject * obj0 = 0 ;
25695 PyObject * obj1 = 0 ;
25696 char *kwnames[] = {
25697 (char *) "self",(char *) "factor", NULL
25698 };
25699
25700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25702 if (SWIG_arg_fail(1)) SWIG_fail;
25703 {
25704 arg2 = (int)(SWIG_As_int(obj1));
25705 if (SWIG_arg_fail(2)) SWIG_fail;
25706 }
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 {
25710 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25711 result = (wxDateSpan *) &_result_ref;
25712 }
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj;
25726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25727 wxDateSpan *arg2 = 0 ;
25728 wxDateSpan result;
25729 PyObject * obj0 = 0 ;
25730 PyObject * obj1 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "self",(char *) "other", NULL
25733 };
25734
25735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25737 if (SWIG_arg_fail(1)) SWIG_fail;
25738 {
25739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(2)) SWIG_fail;
25741 if (arg2 == NULL) {
25742 SWIG_null_ref("wxDateSpan");
25743 }
25744 if (SWIG_arg_fail(2)) SWIG_fail;
25745 }
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25749
25750 wxPyEndAllowThreads(__tstate);
25751 if (PyErr_Occurred()) SWIG_fail;
25752 }
25753 {
25754 wxDateSpan * resultptr;
25755 resultptr = new wxDateSpan((wxDateSpan &)(result));
25756 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25757 }
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25767 wxDateSpan *arg2 = 0 ;
25768 wxDateSpan result;
25769 PyObject * obj0 = 0 ;
25770 PyObject * obj1 = 0 ;
25771 char *kwnames[] = {
25772 (char *) "self",(char *) "other", NULL
25773 };
25774
25775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25777 if (SWIG_arg_fail(1)) SWIG_fail;
25778 {
25779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(2)) SWIG_fail;
25781 if (arg2 == NULL) {
25782 SWIG_null_ref("wxDateSpan");
25783 }
25784 if (SWIG_arg_fail(2)) SWIG_fail;
25785 }
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25789
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 {
25794 wxDateSpan * resultptr;
25795 resultptr = new wxDateSpan((wxDateSpan &)(result));
25796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj;
25806 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25807 int arg2 ;
25808 wxDateSpan result;
25809 PyObject * obj0 = 0 ;
25810 PyObject * obj1 = 0 ;
25811 char *kwnames[] = {
25812 (char *) "self",(char *) "n", NULL
25813 };
25814
25815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25817 if (SWIG_arg_fail(1)) SWIG_fail;
25818 {
25819 arg2 = (int)(SWIG_As_int(obj1));
25820 if (SWIG_arg_fail(2)) SWIG_fail;
25821 }
25822 {
25823 PyThreadState* __tstate = wxPyBeginAllowThreads();
25824 result = wxDateSpan___mul__(arg1,arg2);
25825
25826 wxPyEndAllowThreads(__tstate);
25827 if (PyErr_Occurred()) SWIG_fail;
25828 }
25829 {
25830 wxDateSpan * resultptr;
25831 resultptr = new wxDateSpan((wxDateSpan &)(result));
25832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25833 }
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25841 PyObject *resultobj;
25842 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25843 int arg2 ;
25844 wxDateSpan result;
25845 PyObject * obj0 = 0 ;
25846 PyObject * obj1 = 0 ;
25847 char *kwnames[] = {
25848 (char *) "self",(char *) "n", NULL
25849 };
25850
25851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25853 if (SWIG_arg_fail(1)) SWIG_fail;
25854 {
25855 arg2 = (int)(SWIG_As_int(obj1));
25856 if (SWIG_arg_fail(2)) SWIG_fail;
25857 }
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = wxDateSpan___rmul__(arg1,arg2);
25861
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 {
25866 wxDateSpan * resultptr;
25867 resultptr = new wxDateSpan((wxDateSpan &)(result));
25868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25869 }
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj;
25878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25879 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25880 bool result;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char *kwnames[] = {
25884 (char *) "self",(char *) "other", NULL
25885 };
25886
25887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(1)) SWIG_fail;
25890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(2)) SWIG_fail;
25892 {
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25895
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 {
25900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25901 }
25902 return resultobj;
25903 fail:
25904 return NULL;
25905 }
25906
25907
25908 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25909 PyObject *resultobj;
25910 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25911 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25912 bool result;
25913 PyObject * obj0 = 0 ;
25914 PyObject * obj1 = 0 ;
25915 char *kwnames[] = {
25916 (char *) "self",(char *) "other", NULL
25917 };
25918
25919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25921 if (SWIG_arg_fail(1)) SWIG_fail;
25922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25923 if (SWIG_arg_fail(2)) SWIG_fail;
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25927
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 {
25932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25933 }
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25941 PyObject *obj;
25942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25943 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25944 Py_INCREF(obj);
25945 return Py_BuildValue((char *)"");
25946 }
25947 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25948 PyObject *resultobj;
25949 long result;
25950 char *kwnames[] = {
25951 NULL
25952 };
25953
25954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 result = (long)wxGetLocalTime();
25958
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 resultobj = SWIG_From_long((long)(result));
25964 }
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj;
25973 long result;
25974 char *kwnames[] = {
25975 NULL
25976 };
25977
25978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25979 {
25980 PyThreadState* __tstate = wxPyBeginAllowThreads();
25981 result = (long)wxGetUTCTime();
25982
25983 wxPyEndAllowThreads(__tstate);
25984 if (PyErr_Occurred()) SWIG_fail;
25985 }
25986 {
25987 resultobj = SWIG_From_long((long)(result));
25988 }
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25996 PyObject *resultobj;
25997 long result;
25998 char *kwnames[] = {
25999 NULL
26000 };
26001
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 result = (long)wxGetCurrentTime();
26006
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 {
26011 resultobj = SWIG_From_long((long)(result));
26012 }
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxLongLong result;
26022 char *kwnames[] = {
26023 NULL
26024 };
26025
26026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = wxGetLocalTimeMillis();
26030
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 {
26035 PyObject *hi, *lo, *shifter, *shifted;
26036 hi = PyLong_FromLong( (&result)->GetHi() );
26037 lo = PyLong_FromLong( (&result)->GetLo() );
26038 shifter = PyLong_FromLong(32);
26039 shifted = PyNumber_Lshift(hi, shifter);
26040 resultobj = PyNumber_Or(shifted, lo);
26041 Py_DECREF(hi);
26042 Py_DECREF(lo);
26043 Py_DECREF(shifter);
26044 Py_DECREF(shifted);
26045 }
26046 return resultobj;
26047 fail:
26048 return NULL;
26049 }
26050
26051
26052 static int _wrap_DefaultDateTime_set(PyObject *) {
26053 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26054 return 1;
26055 }
26056
26057
26058 static PyObject *_wrap_DefaultDateTime_get(void) {
26059 PyObject *pyobj;
26060
26061 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26062 return pyobj;
26063 }
26064
26065
26066 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26067 PyObject *resultobj;
26068 wxDataFormatId arg1 ;
26069 wxDataFormat *result;
26070 PyObject * obj0 = 0 ;
26071 char *kwnames[] = {
26072 (char *) "type", NULL
26073 };
26074
26075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26076 {
26077 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26078 if (SWIG_arg_fail(1)) SWIG_fail;
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26083
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj;
26096 wxString *arg1 = 0 ;
26097 wxDataFormat *result;
26098 bool temp1 = false ;
26099 PyObject * obj0 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "format", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26105 {
26106 arg1 = wxString_in_helper(obj0);
26107 if (arg1 == NULL) SWIG_fail;
26108 temp1 = true;
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26113
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26118 {
26119 if (temp1)
26120 delete arg1;
26121 }
26122 return resultobj;
26123 fail:
26124 {
26125 if (temp1)
26126 delete arg1;
26127 }
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26135 PyObject * obj0 = 0 ;
26136 char *kwnames[] = {
26137 (char *) "self", NULL
26138 };
26139
26140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26142 if (SWIG_arg_fail(1)) SWIG_fail;
26143 {
26144 PyThreadState* __tstate = wxPyBeginAllowThreads();
26145 delete arg1;
26146
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 Py_INCREF(Py_None); resultobj = Py_None;
26151 return resultobj;
26152 fail:
26153 return NULL;
26154 }
26155
26156
26157 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26158 PyObject *resultobj;
26159 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26160 wxDataFormatId arg2 ;
26161 bool result;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164
26165 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26167 if (SWIG_arg_fail(1)) SWIG_fail;
26168 {
26169 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26170 if (SWIG_arg_fail(2)) SWIG_fail;
26171 }
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 {
26180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26189 PyObject *resultobj;
26190 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26191 wxDataFormatId arg2 ;
26192 bool result;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195
26196 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 {
26200 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26201 if (SWIG_arg_fail(2)) SWIG_fail;
26202 }
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 {
26211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26212 }
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26220 PyObject *resultobj;
26221 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26222 wxDataFormat *arg2 = 0 ;
26223 bool result;
26224 PyObject * obj0 = 0 ;
26225 PyObject * obj1 = 0 ;
26226
26227 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 {
26231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26232 if (SWIG_arg_fail(2)) SWIG_fail;
26233 if (arg2 == NULL) {
26234 SWIG_null_ref("wxDataFormat");
26235 }
26236 if (SWIG_arg_fail(2)) SWIG_fail;
26237 }
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26241
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26247 }
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26255 int argc;
26256 PyObject *argv[3];
26257 int ii;
26258
26259 argc = PyObject_Length(args);
26260 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26261 argv[ii] = PyTuple_GetItem(args,ii);
26262 }
26263 if (argc == 2) {
26264 int _v;
26265 {
26266 void *ptr;
26267 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26268 _v = 0;
26269 PyErr_Clear();
26270 } else {
26271 _v = 1;
26272 }
26273 }
26274 if (_v) {
26275 {
26276 void *ptr = 0;
26277 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26278 _v = 0;
26279 PyErr_Clear();
26280 } else {
26281 _v = (ptr != 0);
26282 }
26283 }
26284 if (_v) {
26285 return _wrap_DataFormat___eq____SWIG_1(self,args);
26286 }
26287 }
26288 }
26289 if (argc == 2) {
26290 int _v;
26291 {
26292 void *ptr;
26293 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26294 _v = 0;
26295 PyErr_Clear();
26296 } else {
26297 _v = 1;
26298 }
26299 }
26300 if (_v) {
26301 _v = SWIG_Check_int(argv[1]);
26302 if (_v) {
26303 return _wrap_DataFormat___eq____SWIG_0(self,args);
26304 }
26305 }
26306 }
26307
26308 Py_INCREF(Py_NotImplemented);
26309 return Py_NotImplemented;
26310 }
26311
26312
26313 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26314 PyObject *resultobj;
26315 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26316 wxDataFormat *arg2 = 0 ;
26317 bool result;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320
26321 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26323 if (SWIG_arg_fail(1)) SWIG_fail;
26324 {
26325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(2)) SWIG_fail;
26327 if (arg2 == NULL) {
26328 SWIG_null_ref("wxDataFormat");
26329 }
26330 if (SWIG_arg_fail(2)) SWIG_fail;
26331 }
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26335
26336 wxPyEndAllowThreads(__tstate);
26337 if (PyErr_Occurred()) SWIG_fail;
26338 }
26339 {
26340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26341 }
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26349 int argc;
26350 PyObject *argv[3];
26351 int ii;
26352
26353 argc = PyObject_Length(args);
26354 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26355 argv[ii] = PyTuple_GetItem(args,ii);
26356 }
26357 if (argc == 2) {
26358 int _v;
26359 {
26360 void *ptr;
26361 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26362 _v = 0;
26363 PyErr_Clear();
26364 } else {
26365 _v = 1;
26366 }
26367 }
26368 if (_v) {
26369 {
26370 void *ptr = 0;
26371 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26372 _v = 0;
26373 PyErr_Clear();
26374 } else {
26375 _v = (ptr != 0);
26376 }
26377 }
26378 if (_v) {
26379 return _wrap_DataFormat___ne____SWIG_1(self,args);
26380 }
26381 }
26382 }
26383 if (argc == 2) {
26384 int _v;
26385 {
26386 void *ptr;
26387 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26388 _v = 0;
26389 PyErr_Clear();
26390 } else {
26391 _v = 1;
26392 }
26393 }
26394 if (_v) {
26395 _v = SWIG_Check_int(argv[1]);
26396 if (_v) {
26397 return _wrap_DataFormat___ne____SWIG_0(self,args);
26398 }
26399 }
26400 }
26401
26402 Py_INCREF(Py_NotImplemented);
26403 return Py_NotImplemented;
26404 }
26405
26406
26407 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26408 PyObject *resultobj;
26409 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26410 wxDataFormatId arg2 ;
26411 PyObject * obj0 = 0 ;
26412 PyObject * obj1 = 0 ;
26413 char *kwnames[] = {
26414 (char *) "self",(char *) "format", NULL
26415 };
26416
26417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26419 if (SWIG_arg_fail(1)) SWIG_fail;
26420 {
26421 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26422 if (SWIG_arg_fail(2)) SWIG_fail;
26423 }
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 (arg1)->SetType((wxDataFormatId )arg2);
26427
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 Py_INCREF(Py_None); resultobj = Py_None;
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26439 PyObject *resultobj;
26440 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26441 wxDataFormatId result;
26442 PyObject * obj0 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_From_int((result));
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj;
26466 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26467 wxString result;
26468 PyObject * obj0 = 0 ;
26469 char *kwnames[] = {
26470 (char *) "self", NULL
26471 };
26472
26473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26475 if (SWIG_arg_fail(1)) SWIG_fail;
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = ((wxDataFormat const *)arg1)->GetId();
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 {
26484 #if wxUSE_UNICODE
26485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26486 #else
26487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26488 #endif
26489 }
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj;
26498 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26499 wxString *arg2 = 0 ;
26500 bool temp2 = false ;
26501 PyObject * obj0 = 0 ;
26502 PyObject * obj1 = 0 ;
26503 char *kwnames[] = {
26504 (char *) "self",(char *) "format", NULL
26505 };
26506
26507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26509 if (SWIG_arg_fail(1)) SWIG_fail;
26510 {
26511 arg2 = wxString_in_helper(obj1);
26512 if (arg2 == NULL) SWIG_fail;
26513 temp2 = true;
26514 }
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 (arg1)->SetId((wxString const &)*arg2);
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 Py_INCREF(Py_None); resultobj = Py_None;
26523 {
26524 if (temp2)
26525 delete arg2;
26526 }
26527 return resultobj;
26528 fail:
26529 {
26530 if (temp2)
26531 delete arg2;
26532 }
26533 return NULL;
26534 }
26535
26536
26537 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26538 PyObject *obj;
26539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26540 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26541 Py_INCREF(obj);
26542 return Py_BuildValue((char *)"");
26543 }
26544 static int _wrap_FormatInvalid_set(PyObject *) {
26545 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26546 return 1;
26547 }
26548
26549
26550 static PyObject *_wrap_FormatInvalid_get(void) {
26551 PyObject *pyobj;
26552
26553 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26554 return pyobj;
26555 }
26556
26557
26558 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26559 PyObject *resultobj;
26560 wxDataObject *arg1 = (wxDataObject *) 0 ;
26561 PyObject * obj0 = 0 ;
26562 char *kwnames[] = {
26563 (char *) "self", NULL
26564 };
26565
26566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26568 if (SWIG_arg_fail(1)) SWIG_fail;
26569 {
26570 PyThreadState* __tstate = wxPyBeginAllowThreads();
26571 delete arg1;
26572
26573 wxPyEndAllowThreads(__tstate);
26574 if (PyErr_Occurred()) SWIG_fail;
26575 }
26576 Py_INCREF(Py_None); resultobj = Py_None;
26577 return resultobj;
26578 fail:
26579 return NULL;
26580 }
26581
26582
26583 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj;
26585 wxDataObject *arg1 = (wxDataObject *) 0 ;
26586 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26587 SwigValueWrapper<wxDataFormat > result;
26588 PyObject * obj0 = 0 ;
26589 PyObject * obj1 = 0 ;
26590 char *kwnames[] = {
26591 (char *) "self",(char *) "dir", NULL
26592 };
26593
26594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26596 if (SWIG_arg_fail(1)) SWIG_fail;
26597 if (obj1) {
26598 {
26599 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26600 if (SWIG_arg_fail(2)) SWIG_fail;
26601 }
26602 }
26603 {
26604 PyThreadState* __tstate = wxPyBeginAllowThreads();
26605 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26606
26607 wxPyEndAllowThreads(__tstate);
26608 if (PyErr_Occurred()) SWIG_fail;
26609 }
26610 {
26611 wxDataFormat * resultptr;
26612 resultptr = new wxDataFormat((wxDataFormat &)(result));
26613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26614 }
26615 return resultobj;
26616 fail:
26617 return NULL;
26618 }
26619
26620
26621 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj;
26623 wxDataObject *arg1 = (wxDataObject *) 0 ;
26624 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26625 size_t result;
26626 PyObject * obj0 = 0 ;
26627 PyObject * obj1 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self",(char *) "dir", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26634 if (SWIG_arg_fail(1)) SWIG_fail;
26635 if (obj1) {
26636 {
26637 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26638 if (SWIG_arg_fail(2)) SWIG_fail;
26639 }
26640 }
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26644
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 {
26649 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26650 }
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj;
26659 wxDataObject *arg1 = (wxDataObject *) 0 ;
26660 wxDataFormat *arg2 = 0 ;
26661 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26662 bool result;
26663 PyObject * obj0 = 0 ;
26664 PyObject * obj1 = 0 ;
26665 PyObject * obj2 = 0 ;
26666 char *kwnames[] = {
26667 (char *) "self",(char *) "format",(char *) "dir", NULL
26668 };
26669
26670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26672 if (SWIG_arg_fail(1)) SWIG_fail;
26673 {
26674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26675 if (SWIG_arg_fail(2)) SWIG_fail;
26676 if (arg2 == NULL) {
26677 SWIG_null_ref("wxDataFormat");
26678 }
26679 if (SWIG_arg_fail(2)) SWIG_fail;
26680 }
26681 if (obj2) {
26682 {
26683 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26684 if (SWIG_arg_fail(3)) SWIG_fail;
26685 }
26686 }
26687 {
26688 PyThreadState* __tstate = wxPyBeginAllowThreads();
26689 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26690
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 {
26695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26696 }
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26704 PyObject *resultobj;
26705 wxDataObject *arg1 = (wxDataObject *) 0 ;
26706 wxDataFormat *arg2 = 0 ;
26707 size_t result;
26708 PyObject * obj0 = 0 ;
26709 PyObject * obj1 = 0 ;
26710 char *kwnames[] = {
26711 (char *) "self",(char *) "format", NULL
26712 };
26713
26714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26716 if (SWIG_arg_fail(1)) SWIG_fail;
26717 {
26718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26719 if (SWIG_arg_fail(2)) SWIG_fail;
26720 if (arg2 == NULL) {
26721 SWIG_null_ref("wxDataFormat");
26722 }
26723 if (SWIG_arg_fail(2)) SWIG_fail;
26724 }
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26728
26729 wxPyEndAllowThreads(__tstate);
26730 if (PyErr_Occurred()) SWIG_fail;
26731 }
26732 {
26733 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26734 }
26735 return resultobj;
26736 fail:
26737 return NULL;
26738 }
26739
26740
26741 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26742 PyObject *resultobj;
26743 wxDataObject *arg1 = (wxDataObject *) 0 ;
26744 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26745 PyObject *result;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 char *kwnames[] = {
26749 (char *) "self",(char *) "dir", NULL
26750 };
26751
26752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26754 if (SWIG_arg_fail(1)) SWIG_fail;
26755 if (obj1) {
26756 {
26757 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26758 if (SWIG_arg_fail(2)) SWIG_fail;
26759 }
26760 }
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26764
26765 wxPyEndAllowThreads(__tstate);
26766 if (PyErr_Occurred()) SWIG_fail;
26767 }
26768 resultobj = result;
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj;
26777 wxDataObject *arg1 = (wxDataObject *) 0 ;
26778 wxDataFormat *arg2 = 0 ;
26779 PyObject *result;
26780 PyObject * obj0 = 0 ;
26781 PyObject * obj1 = 0 ;
26782 char *kwnames[] = {
26783 (char *) "self",(char *) "format", NULL
26784 };
26785
26786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26788 if (SWIG_arg_fail(1)) SWIG_fail;
26789 {
26790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26791 if (SWIG_arg_fail(2)) SWIG_fail;
26792 if (arg2 == NULL) {
26793 SWIG_null_ref("wxDataFormat");
26794 }
26795 if (SWIG_arg_fail(2)) SWIG_fail;
26796 }
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26800
26801 wxPyEndAllowThreads(__tstate);
26802 if (PyErr_Occurred()) SWIG_fail;
26803 }
26804 resultobj = result;
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj;
26813 wxDataObject *arg1 = (wxDataObject *) 0 ;
26814 wxDataFormat *arg2 = 0 ;
26815 PyObject *arg3 = (PyObject *) 0 ;
26816 bool result;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 PyObject * obj2 = 0 ;
26820 char *kwnames[] = {
26821 (char *) "self",(char *) "format",(char *) "data", NULL
26822 };
26823
26824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26826 if (SWIG_arg_fail(1)) SWIG_fail;
26827 {
26828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26829 if (SWIG_arg_fail(2)) SWIG_fail;
26830 if (arg2 == NULL) {
26831 SWIG_null_ref("wxDataFormat");
26832 }
26833 if (SWIG_arg_fail(2)) SWIG_fail;
26834 }
26835 arg3 = obj2;
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26839
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26853 PyObject *obj;
26854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26855 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26856 Py_INCREF(obj);
26857 return Py_BuildValue((char *)"");
26858 }
26859 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26862 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26863 wxDataObjectSimple *result;
26864 PyObject * obj0 = 0 ;
26865 char *kwnames[] = {
26866 (char *) "format", NULL
26867 };
26868
26869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26870 if (obj0) {
26871 {
26872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26873 if (SWIG_arg_fail(1)) SWIG_fail;
26874 if (arg1 == NULL) {
26875 SWIG_null_ref("wxDataFormat");
26876 }
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 }
26879 }
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj;
26896 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26897 wxDataFormat *result;
26898 PyObject * obj0 = 0 ;
26899 char *kwnames[] = {
26900 (char *) "self", NULL
26901 };
26902
26903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26905 if (SWIG_arg_fail(1)) SWIG_fail;
26906 {
26907 PyThreadState* __tstate = wxPyBeginAllowThreads();
26908 {
26909 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26910 result = (wxDataFormat *) &_result_ref;
26911 }
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26926 wxDataFormat *arg2 = 0 ;
26927 PyObject * obj0 = 0 ;
26928 PyObject * obj1 = 0 ;
26929 char *kwnames[] = {
26930 (char *) "self",(char *) "format", NULL
26931 };
26932
26933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26935 if (SWIG_arg_fail(1)) SWIG_fail;
26936 {
26937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26938 if (SWIG_arg_fail(2)) SWIG_fail;
26939 if (arg2 == NULL) {
26940 SWIG_null_ref("wxDataFormat");
26941 }
26942 if (SWIG_arg_fail(2)) SWIG_fail;
26943 }
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26947
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 Py_INCREF(Py_None); resultobj = Py_None;
26952 return resultobj;
26953 fail:
26954 return NULL;
26955 }
26956
26957
26958 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26959 PyObject *resultobj;
26960 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26961 size_t result;
26962 PyObject * obj0 = 0 ;
26963 char *kwnames[] = {
26964 (char *) "self", NULL
26965 };
26966
26967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26969 if (SWIG_arg_fail(1)) SWIG_fail;
26970 {
26971 PyThreadState* __tstate = wxPyBeginAllowThreads();
26972 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26973
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 {
26978 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26979 }
26980 return resultobj;
26981 fail:
26982 return NULL;
26983 }
26984
26985
26986 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26987 PyObject *resultobj;
26988 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26989 PyObject *result;
26990 PyObject * obj0 = 0 ;
26991 char *kwnames[] = {
26992 (char *) "self", NULL
26993 };
26994
26995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26997 if (SWIG_arg_fail(1)) SWIG_fail;
26998 {
26999 PyThreadState* __tstate = wxPyBeginAllowThreads();
27000 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27001
27002 wxPyEndAllowThreads(__tstate);
27003 if (PyErr_Occurred()) SWIG_fail;
27004 }
27005 resultobj = result;
27006 return resultobj;
27007 fail:
27008 return NULL;
27009 }
27010
27011
27012 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27013 PyObject *resultobj;
27014 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27015 PyObject *arg2 = (PyObject *) 0 ;
27016 bool result;
27017 PyObject * obj0 = 0 ;
27018 PyObject * obj1 = 0 ;
27019 char *kwnames[] = {
27020 (char *) "self",(char *) "data", NULL
27021 };
27022
27023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27025 if (SWIG_arg_fail(1)) SWIG_fail;
27026 arg2 = obj1;
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27030
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 {
27035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27036 }
27037 return resultobj;
27038 fail:
27039 return NULL;
27040 }
27041
27042
27043 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27044 PyObject *obj;
27045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27046 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27047 Py_INCREF(obj);
27048 return Py_BuildValue((char *)"");
27049 }
27050 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27051 PyObject *resultobj;
27052 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27053 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27054 wxPyDataObjectSimple *result;
27055 PyObject * obj0 = 0 ;
27056 char *kwnames[] = {
27057 (char *) "format", NULL
27058 };
27059
27060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27061 if (obj0) {
27062 {
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 if (arg1 == NULL) {
27066 SWIG_null_ref("wxDataFormat");
27067 }
27068 if (SWIG_arg_fail(1)) SWIG_fail;
27069 }
27070 }
27071 {
27072 PyThreadState* __tstate = wxPyBeginAllowThreads();
27073 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27074
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj;
27087 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27088 PyObject *arg2 = (PyObject *) 0 ;
27089 PyObject *arg3 = (PyObject *) 0 ;
27090 PyObject * obj0 = 0 ;
27091 PyObject * obj1 = 0 ;
27092 PyObject * obj2 = 0 ;
27093 char *kwnames[] = {
27094 (char *) "self",(char *) "self",(char *) "_class", NULL
27095 };
27096
27097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27099 if (SWIG_arg_fail(1)) SWIG_fail;
27100 arg2 = obj1;
27101 arg3 = obj2;
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 (arg1)->_setCallbackInfo(arg2,arg3);
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 Py_INCREF(Py_None); resultobj = Py_None;
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27117 PyObject *obj;
27118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27119 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27120 Py_INCREF(obj);
27121 return Py_BuildValue((char *)"");
27122 }
27123 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27124 PyObject *resultobj;
27125 wxDataObjectComposite *result;
27126 char *kwnames[] = {
27127 NULL
27128 };
27129
27130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27131 {
27132 PyThreadState* __tstate = wxPyBeginAllowThreads();
27133 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27134
27135 wxPyEndAllowThreads(__tstate);
27136 if (PyErr_Occurred()) SWIG_fail;
27137 }
27138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27139 return resultobj;
27140 fail:
27141 return NULL;
27142 }
27143
27144
27145 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj;
27147 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27148 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27149 bool arg3 = (bool) false ;
27150 PyObject * obj0 = 0 ;
27151 PyObject * obj1 = 0 ;
27152 PyObject * obj2 = 0 ;
27153 char *kwnames[] = {
27154 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27155 };
27156
27157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27159 if (SWIG_arg_fail(1)) SWIG_fail;
27160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27161 if (SWIG_arg_fail(2)) SWIG_fail;
27162 if (obj2) {
27163 {
27164 arg3 = (bool)(SWIG_As_bool(obj2));
27165 if (SWIG_arg_fail(3)) SWIG_fail;
27166 }
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 (arg1)->Add(arg2,arg3);
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 Py_INCREF(Py_None); resultobj = Py_None;
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27183 PyObject *obj;
27184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27185 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27186 Py_INCREF(obj);
27187 return Py_BuildValue((char *)"");
27188 }
27189 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj;
27191 wxString const &arg1_defvalue = wxPyEmptyString ;
27192 wxString *arg1 = (wxString *) &arg1_defvalue ;
27193 wxTextDataObject *result;
27194 bool temp1 = false ;
27195 PyObject * obj0 = 0 ;
27196 char *kwnames[] = {
27197 (char *) "text", NULL
27198 };
27199
27200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27201 if (obj0) {
27202 {
27203 arg1 = wxString_in_helper(obj0);
27204 if (arg1 == NULL) SWIG_fail;
27205 temp1 = true;
27206 }
27207 }
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27211
27212 wxPyEndAllowThreads(__tstate);
27213 if (PyErr_Occurred()) SWIG_fail;
27214 }
27215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27216 {
27217 if (temp1)
27218 delete arg1;
27219 }
27220 return resultobj;
27221 fail:
27222 {
27223 if (temp1)
27224 delete arg1;
27225 }
27226 return NULL;
27227 }
27228
27229
27230 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj;
27232 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27233 size_t result;
27234 PyObject * obj0 = 0 ;
27235 char *kwnames[] = {
27236 (char *) "self", NULL
27237 };
27238
27239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27241 if (SWIG_arg_fail(1)) SWIG_fail;
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 result = (size_t)(arg1)->GetTextLength();
27245
27246 wxPyEndAllowThreads(__tstate);
27247 if (PyErr_Occurred()) SWIG_fail;
27248 }
27249 {
27250 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27251 }
27252 return resultobj;
27253 fail:
27254 return NULL;
27255 }
27256
27257
27258 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27259 PyObject *resultobj;
27260 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27261 wxString result;
27262 PyObject * obj0 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (arg1)->GetText();
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 {
27278 #if wxUSE_UNICODE
27279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27280 #else
27281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27282 #endif
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj;
27292 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27293 wxString *arg2 = 0 ;
27294 bool temp2 = false ;
27295 PyObject * obj0 = 0 ;
27296 PyObject * obj1 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self",(char *) "text", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 arg2 = wxString_in_helper(obj1);
27306 if (arg2 == NULL) SWIG_fail;
27307 temp2 = true;
27308 }
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 (arg1)->SetText((wxString const &)*arg2);
27312
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 Py_INCREF(Py_None); resultobj = Py_None;
27317 {
27318 if (temp2)
27319 delete arg2;
27320 }
27321 return resultobj;
27322 fail:
27323 {
27324 if (temp2)
27325 delete arg2;
27326 }
27327 return NULL;
27328 }
27329
27330
27331 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27332 PyObject *obj;
27333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27334 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27335 Py_INCREF(obj);
27336 return Py_BuildValue((char *)"");
27337 }
27338 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27339 PyObject *resultobj;
27340 wxString const &arg1_defvalue = wxPyEmptyString ;
27341 wxString *arg1 = (wxString *) &arg1_defvalue ;
27342 wxPyTextDataObject *result;
27343 bool temp1 = false ;
27344 PyObject * obj0 = 0 ;
27345 char *kwnames[] = {
27346 (char *) "text", NULL
27347 };
27348
27349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27350 if (obj0) {
27351 {
27352 arg1 = wxString_in_helper(obj0);
27353 if (arg1 == NULL) SWIG_fail;
27354 temp1 = true;
27355 }
27356 }
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27365 {
27366 if (temp1)
27367 delete arg1;
27368 }
27369 return resultobj;
27370 fail:
27371 {
27372 if (temp1)
27373 delete arg1;
27374 }
27375 return NULL;
27376 }
27377
27378
27379 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj;
27381 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27382 PyObject *arg2 = (PyObject *) 0 ;
27383 PyObject *arg3 = (PyObject *) 0 ;
27384 PyObject * obj0 = 0 ;
27385 PyObject * obj1 = 0 ;
27386 PyObject * obj2 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self",(char *) "self",(char *) "_class", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 arg2 = obj1;
27395 arg3 = obj2;
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->_setCallbackInfo(arg2,arg3);
27399
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 Py_INCREF(Py_None); resultobj = Py_None;
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27411 PyObject *obj;
27412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27413 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27414 Py_INCREF(obj);
27415 return Py_BuildValue((char *)"");
27416 }
27417 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj;
27419 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27420 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27421 wxBitmapDataObject *result;
27422 PyObject * obj0 = 0 ;
27423 char *kwnames[] = {
27424 (char *) "bitmap", NULL
27425 };
27426
27427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27428 if (obj0) {
27429 {
27430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27431 if (SWIG_arg_fail(1)) SWIG_fail;
27432 if (arg1 == NULL) {
27433 SWIG_null_ref("wxBitmap");
27434 }
27435 if (SWIG_arg_fail(1)) SWIG_fail;
27436 }
27437 }
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27441
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj;
27454 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27455 wxBitmap result;
27456 PyObject * obj0 = 0 ;
27457 char *kwnames[] = {
27458 (char *) "self", NULL
27459 };
27460
27461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27463 if (SWIG_arg_fail(1)) SWIG_fail;
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27467
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 {
27472 wxBitmap * resultptr;
27473 resultptr = new wxBitmap((wxBitmap &)(result));
27474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27475 }
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27483 PyObject *resultobj;
27484 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27485 wxBitmap *arg2 = 0 ;
27486 PyObject * obj0 = 0 ;
27487 PyObject * obj1 = 0 ;
27488 char *kwnames[] = {
27489 (char *) "self",(char *) "bitmap", NULL
27490 };
27491
27492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27494 if (SWIG_arg_fail(1)) SWIG_fail;
27495 {
27496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(2)) SWIG_fail;
27498 if (arg2 == NULL) {
27499 SWIG_null_ref("wxBitmap");
27500 }
27501 if (SWIG_arg_fail(2)) SWIG_fail;
27502 }
27503 {
27504 PyThreadState* __tstate = wxPyBeginAllowThreads();
27505 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27506
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 Py_INCREF(Py_None); resultobj = Py_None;
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27518 PyObject *obj;
27519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27520 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27521 Py_INCREF(obj);
27522 return Py_BuildValue((char *)"");
27523 }
27524 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27525 PyObject *resultobj;
27526 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27527 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27528 wxPyBitmapDataObject *result;
27529 PyObject * obj0 = 0 ;
27530 char *kwnames[] = {
27531 (char *) "bitmap", NULL
27532 };
27533
27534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27535 if (obj0) {
27536 {
27537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27538 if (SWIG_arg_fail(1)) SWIG_fail;
27539 if (arg1 == NULL) {
27540 SWIG_null_ref("wxBitmap");
27541 }
27542 if (SWIG_arg_fail(1)) SWIG_fail;
27543 }
27544 }
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27548
27549 wxPyEndAllowThreads(__tstate);
27550 if (PyErr_Occurred()) SWIG_fail;
27551 }
27552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27553 return resultobj;
27554 fail:
27555 return NULL;
27556 }
27557
27558
27559 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj;
27561 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27562 PyObject *arg2 = (PyObject *) 0 ;
27563 PyObject *arg3 = (PyObject *) 0 ;
27564 PyObject * obj0 = 0 ;
27565 PyObject * obj1 = 0 ;
27566 PyObject * obj2 = 0 ;
27567 char *kwnames[] = {
27568 (char *) "self",(char *) "self",(char *) "_class", NULL
27569 };
27570
27571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27573 if (SWIG_arg_fail(1)) SWIG_fail;
27574 arg2 = obj1;
27575 arg3 = obj2;
27576 {
27577 PyThreadState* __tstate = wxPyBeginAllowThreads();
27578 (arg1)->_setCallbackInfo(arg2,arg3);
27579
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 Py_INCREF(Py_None); resultobj = Py_None;
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27591 PyObject *obj;
27592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27593 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27594 Py_INCREF(obj);
27595 return Py_BuildValue((char *)"");
27596 }
27597 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj;
27599 wxFileDataObject *result;
27600 char *kwnames[] = {
27601 NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 result = (wxFileDataObject *)new wxFileDataObject();
27608
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj;
27621 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27622 wxArrayString *result;
27623 PyObject * obj0 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 {
27634 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27635 result = (wxArrayString *) &_result_ref;
27636 }
27637
27638 wxPyEndAllowThreads(__tstate);
27639 if (PyErr_Occurred()) SWIG_fail;
27640 }
27641 {
27642 resultobj = wxArrayString2PyList_helper(*result);
27643 }
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj;
27652 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27653 wxString *arg2 = 0 ;
27654 bool temp2 = false ;
27655 PyObject * obj0 = 0 ;
27656 PyObject * obj1 = 0 ;
27657 char *kwnames[] = {
27658 (char *) "self",(char *) "filename", NULL
27659 };
27660
27661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27663 if (SWIG_arg_fail(1)) SWIG_fail;
27664 {
27665 arg2 = wxString_in_helper(obj1);
27666 if (arg2 == NULL) SWIG_fail;
27667 temp2 = true;
27668 }
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->AddFile((wxString const &)*arg2);
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 Py_INCREF(Py_None); resultobj = Py_None;
27677 {
27678 if (temp2)
27679 delete arg2;
27680 }
27681 return resultobj;
27682 fail:
27683 {
27684 if (temp2)
27685 delete arg2;
27686 }
27687 return NULL;
27688 }
27689
27690
27691 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27692 PyObject *obj;
27693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27694 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27695 Py_INCREF(obj);
27696 return Py_BuildValue((char *)"");
27697 }
27698 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27699 PyObject *resultobj;
27700 wxDataFormat *arg1 = 0 ;
27701 wxCustomDataObject *result;
27702 PyObject * obj0 = 0 ;
27703
27704 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27705 {
27706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27707 if (SWIG_arg_fail(1)) SWIG_fail;
27708 if (arg1 == NULL) {
27709 SWIG_null_ref("wxDataFormat");
27710 }
27711 if (SWIG_arg_fail(1)) SWIG_fail;
27712 }
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27728 PyObject *resultobj;
27729 wxString *arg1 = 0 ;
27730 wxCustomDataObject *result;
27731 bool temp1 = false ;
27732 PyObject * obj0 = 0 ;
27733
27734 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27735 {
27736 arg1 = wxString_in_helper(obj0);
27737 if (arg1 == NULL) SWIG_fail;
27738 temp1 = true;
27739 }
27740 {
27741 PyThreadState* __tstate = wxPyBeginAllowThreads();
27742 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27743
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27748 {
27749 if (temp1)
27750 delete arg1;
27751 }
27752 return resultobj;
27753 fail:
27754 {
27755 if (temp1)
27756 delete arg1;
27757 }
27758 return NULL;
27759 }
27760
27761
27762 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27763 PyObject *resultobj;
27764 wxCustomDataObject *result;
27765
27766 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (wxCustomDataObject *)new wxCustomDataObject();
27770
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27782 int argc;
27783 PyObject *argv[2];
27784 int ii;
27785
27786 argc = PyObject_Length(args);
27787 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27788 argv[ii] = PyTuple_GetItem(args,ii);
27789 }
27790 if (argc == 0) {
27791 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27792 }
27793 if (argc == 1) {
27794 int _v;
27795 {
27796 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27797 }
27798 if (_v) {
27799 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27800 }
27801 }
27802 if (argc == 1) {
27803 int _v;
27804 {
27805 void *ptr = 0;
27806 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27807 _v = 0;
27808 PyErr_Clear();
27809 } else {
27810 _v = (ptr != 0);
27811 }
27812 }
27813 if (_v) {
27814 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27815 }
27816 }
27817
27818 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27819 return NULL;
27820 }
27821
27822
27823 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27824 PyObject *resultobj;
27825 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27826 PyObject *arg2 = (PyObject *) 0 ;
27827 bool result;
27828 PyObject * obj0 = 0 ;
27829 PyObject * obj1 = 0 ;
27830 char *kwnames[] = {
27831 (char *) "self",(char *) "data", NULL
27832 };
27833
27834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27836 if (SWIG_arg_fail(1)) SWIG_fail;
27837 arg2 = obj1;
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27841
27842 wxPyEndAllowThreads(__tstate);
27843 if (PyErr_Occurred()) SWIG_fail;
27844 }
27845 {
27846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27847 }
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27855 PyObject *resultobj;
27856 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27857 size_t result;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "self", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (size_t)(arg1)->GetSize();
27869
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 {
27874 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27875 }
27876 return resultobj;
27877 fail:
27878 return NULL;
27879 }
27880
27881
27882 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27883 PyObject *resultobj;
27884 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27885 PyObject *result;
27886 PyObject * obj0 = 0 ;
27887 char *kwnames[] = {
27888 (char *) "self", NULL
27889 };
27890
27891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27893 if (SWIG_arg_fail(1)) SWIG_fail;
27894 {
27895 PyThreadState* __tstate = wxPyBeginAllowThreads();
27896 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27897
27898 wxPyEndAllowThreads(__tstate);
27899 if (PyErr_Occurred()) SWIG_fail;
27900 }
27901 resultobj = result;
27902 return resultobj;
27903 fail:
27904 return NULL;
27905 }
27906
27907
27908 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27909 PyObject *obj;
27910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27911 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27912 Py_INCREF(obj);
27913 return Py_BuildValue((char *)"");
27914 }
27915 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj;
27917 wxURLDataObject *result;
27918 char *kwnames[] = {
27919 NULL
27920 };
27921
27922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27923 {
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 result = (wxURLDataObject *)new wxURLDataObject();
27926
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27940 wxString result;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (arg1)->GetURL();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 #if wxUSE_UNICODE
27958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27959 #else
27960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27961 #endif
27962 }
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj;
27971 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27972 wxString *arg2 = 0 ;
27973 bool temp2 = false ;
27974 PyObject * obj0 = 0 ;
27975 PyObject * obj1 = 0 ;
27976 char *kwnames[] = {
27977 (char *) "self",(char *) "url", NULL
27978 };
27979
27980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27982 if (SWIG_arg_fail(1)) SWIG_fail;
27983 {
27984 arg2 = wxString_in_helper(obj1);
27985 if (arg2 == NULL) SWIG_fail;
27986 temp2 = true;
27987 }
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 (arg1)->SetURL((wxString const &)*arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 Py_INCREF(Py_None); resultobj = Py_None;
27996 {
27997 if (temp2)
27998 delete arg2;
27999 }
28000 return resultobj;
28001 fail:
28002 {
28003 if (temp2)
28004 delete arg2;
28005 }
28006 return NULL;
28007 }
28008
28009
28010 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28011 PyObject *obj;
28012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28013 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28014 Py_INCREF(obj);
28015 return Py_BuildValue((char *)"");
28016 }
28017 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj;
28019 wxMetafileDataObject *result;
28020 char *kwnames[] = {
28021 NULL
28022 };
28023
28024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28028
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj;
28041 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28042 wxMetafile *arg2 = 0 ;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char *kwnames[] = {
28046 (char *) "self",(char *) "metafile", NULL
28047 };
28048
28049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28051 if (SWIG_arg_fail(1)) SWIG_fail;
28052 {
28053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28054 if (SWIG_arg_fail(2)) SWIG_fail;
28055 if (arg2 == NULL) {
28056 SWIG_null_ref("wxMetafile");
28057 }
28058 if (SWIG_arg_fail(2)) SWIG_fail;
28059 }
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28063
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 Py_INCREF(Py_None); resultobj = Py_None;
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28077 wxMetafile result;
28078 PyObject * obj0 = 0 ;
28079 char *kwnames[] = {
28080 (char *) "self", NULL
28081 };
28082
28083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28085 if (SWIG_arg_fail(1)) SWIG_fail;
28086 {
28087 PyThreadState* __tstate = wxPyBeginAllowThreads();
28088 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28089
28090 wxPyEndAllowThreads(__tstate);
28091 if (PyErr_Occurred()) SWIG_fail;
28092 }
28093 {
28094 wxMetafile * resultptr;
28095 resultptr = new wxMetafile((wxMetafile &)(result));
28096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28097 }
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28105 PyObject *obj;
28106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28107 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28108 Py_INCREF(obj);
28109 return Py_BuildValue((char *)"");
28110 }
28111 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj;
28113 wxDragResult arg1 ;
28114 bool result;
28115 PyObject * obj0 = 0 ;
28116 char *kwnames[] = {
28117 (char *) "res", NULL
28118 };
28119
28120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28121 {
28122 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28134 }
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28142 PyObject *resultobj;
28143 wxWindow *arg1 = (wxWindow *) 0 ;
28144 wxCursor const &arg2_defvalue = wxNullCursor ;
28145 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28146 wxCursor const &arg3_defvalue = wxNullCursor ;
28147 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28148 wxCursor const &arg4_defvalue = wxNullCursor ;
28149 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28150 wxPyDropSource *result;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 PyObject * obj2 = 0 ;
28154 PyObject * obj3 = 0 ;
28155 char *kwnames[] = {
28156 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(1)) SWIG_fail;
28162 if (obj1) {
28163 {
28164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28165 if (SWIG_arg_fail(2)) SWIG_fail;
28166 if (arg2 == NULL) {
28167 SWIG_null_ref("wxCursor");
28168 }
28169 if (SWIG_arg_fail(2)) SWIG_fail;
28170 }
28171 }
28172 if (obj2) {
28173 {
28174 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28175 if (SWIG_arg_fail(3)) SWIG_fail;
28176 if (arg3 == NULL) {
28177 SWIG_null_ref("wxCursor");
28178 }
28179 if (SWIG_arg_fail(3)) SWIG_fail;
28180 }
28181 }
28182 if (obj3) {
28183 {
28184 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28185 if (SWIG_arg_fail(4)) SWIG_fail;
28186 if (arg4 == NULL) {
28187 SWIG_null_ref("wxCursor");
28188 }
28189 if (SWIG_arg_fail(4)) SWIG_fail;
28190 }
28191 }
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28195
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj;
28208 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28209 PyObject *arg2 = (PyObject *) 0 ;
28210 PyObject *arg3 = (PyObject *) 0 ;
28211 int arg4 ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 PyObject * obj2 = 0 ;
28215 PyObject * obj3 = 0 ;
28216 char *kwnames[] = {
28217 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28218 };
28219
28220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28222 if (SWIG_arg_fail(1)) SWIG_fail;
28223 arg2 = obj1;
28224 arg3 = obj2;
28225 {
28226 arg4 = (int)(SWIG_As_int(obj3));
28227 if (SWIG_arg_fail(4)) SWIG_fail;
28228 }
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28232
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 Py_INCREF(Py_None); resultobj = Py_None;
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28244 PyObject *resultobj;
28245 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28246 PyObject * obj0 = 0 ;
28247 char *kwnames[] = {
28248 (char *) "self", NULL
28249 };
28250
28251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28253 if (SWIG_arg_fail(1)) SWIG_fail;
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 delete arg1;
28257
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 Py_INCREF(Py_None); resultobj = Py_None;
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj;
28270 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28271 wxDataObject *arg2 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char *kwnames[] = {
28275 (char *) "self",(char *) "data", NULL
28276 };
28277
28278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28280 if (SWIG_arg_fail(1)) SWIG_fail;
28281 {
28282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(2)) SWIG_fail;
28284 if (arg2 == NULL) {
28285 SWIG_null_ref("wxDataObject");
28286 }
28287 if (SWIG_arg_fail(2)) SWIG_fail;
28288 }
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 (arg1)->SetData(*arg2);
28292
28293 wxPyEndAllowThreads(__tstate);
28294 if (PyErr_Occurred()) SWIG_fail;
28295 }
28296 Py_INCREF(Py_None); resultobj = Py_None;
28297 return resultobj;
28298 fail:
28299 return NULL;
28300 }
28301
28302
28303 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28304 PyObject *resultobj;
28305 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28306 wxDataObject *result;
28307 PyObject * obj0 = 0 ;
28308 char *kwnames[] = {
28309 (char *) "self", NULL
28310 };
28311
28312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28314 if (SWIG_arg_fail(1)) SWIG_fail;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 result = (wxDataObject *)(arg1)->GetDataObject();
28318
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28330 PyObject *resultobj;
28331 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28332 wxDragResult arg2 ;
28333 wxCursor *arg3 = 0 ;
28334 PyObject * obj0 = 0 ;
28335 PyObject * obj1 = 0 ;
28336 PyObject * obj2 = 0 ;
28337 char *kwnames[] = {
28338 (char *) "self",(char *) "res",(char *) "cursor", NULL
28339 };
28340
28341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28343 if (SWIG_arg_fail(1)) SWIG_fail;
28344 {
28345 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28346 if (SWIG_arg_fail(2)) SWIG_fail;
28347 }
28348 {
28349 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28350 if (SWIG_arg_fail(3)) SWIG_fail;
28351 if (arg3 == NULL) {
28352 SWIG_null_ref("wxCursor");
28353 }
28354 if (SWIG_arg_fail(3)) SWIG_fail;
28355 }
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 Py_INCREF(Py_None); resultobj = Py_None;
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28371 PyObject *resultobj;
28372 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28373 int arg2 = (int) wxDrag_CopyOnly ;
28374 wxDragResult result;
28375 PyObject * obj0 = 0 ;
28376 PyObject * obj1 = 0 ;
28377 char *kwnames[] = {
28378 (char *) "self",(char *) "flags", NULL
28379 };
28380
28381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28383 if (SWIG_arg_fail(1)) SWIG_fail;
28384 if (obj1) {
28385 {
28386 arg2 = (int)(SWIG_As_int(obj1));
28387 if (SWIG_arg_fail(2)) SWIG_fail;
28388 }
28389 }
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28393
28394 wxPyEndAllowThreads(__tstate);
28395 if (PyErr_Occurred()) SWIG_fail;
28396 }
28397 resultobj = SWIG_From_int((result));
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj;
28406 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28407 wxDragResult arg2 ;
28408 bool result;
28409 PyObject * obj0 = 0 ;
28410 PyObject * obj1 = 0 ;
28411 char *kwnames[] = {
28412 (char *) "self",(char *) "effect", NULL
28413 };
28414
28415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28417 if (SWIG_arg_fail(1)) SWIG_fail;
28418 {
28419 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28420 if (SWIG_arg_fail(2)) SWIG_fail;
28421 }
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28439 PyObject *obj;
28440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28441 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28442 Py_INCREF(obj);
28443 return Py_BuildValue((char *)"");
28444 }
28445 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28446 PyObject *resultobj;
28447 wxDataObject *arg1 = (wxDataObject *) NULL ;
28448 wxPyDropTarget *result;
28449 PyObject * obj0 = 0 ;
28450 char *kwnames[] = {
28451 (char *) "dataObject", NULL
28452 };
28453
28454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28455 if (obj0) {
28456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28457 if (SWIG_arg_fail(1)) SWIG_fail;
28458 }
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28462
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj;
28475 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28476 PyObject *arg2 = (PyObject *) 0 ;
28477 PyObject *arg3 = (PyObject *) 0 ;
28478 PyObject * obj0 = 0 ;
28479 PyObject * obj1 = 0 ;
28480 PyObject * obj2 = 0 ;
28481 char *kwnames[] = {
28482 (char *) "self",(char *) "self",(char *) "_class", NULL
28483 };
28484
28485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28487 if (SWIG_arg_fail(1)) SWIG_fail;
28488 arg2 = obj1;
28489 arg3 = obj2;
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 (arg1)->_setCallbackInfo(arg2,arg3);
28493
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 Py_INCREF(Py_None); resultobj = Py_None;
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj;
28506 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28507 PyObject * obj0 = 0 ;
28508 char *kwnames[] = {
28509 (char *) "self", NULL
28510 };
28511
28512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28514 if (SWIG_arg_fail(1)) SWIG_fail;
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 delete arg1;
28518
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 Py_INCREF(Py_None); resultobj = Py_None;
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28530 PyObject *resultobj;
28531 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28532 wxDataObject *result;
28533 PyObject * obj0 = 0 ;
28534 char *kwnames[] = {
28535 (char *) "self", NULL
28536 };
28537
28538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(1)) SWIG_fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (wxDataObject *)(arg1)->GetDataObject();
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj;
28557 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28558 wxDataObject *arg2 = (wxDataObject *) 0 ;
28559 PyObject * obj0 = 0 ;
28560 PyObject * obj1 = 0 ;
28561 char *kwnames[] = {
28562 (char *) "self",(char *) "dataObject", NULL
28563 };
28564
28565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28567 if (SWIG_arg_fail(1)) SWIG_fail;
28568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28569 if (SWIG_arg_fail(2)) SWIG_fail;
28570 {
28571 PyThreadState* __tstate = wxPyBeginAllowThreads();
28572 (arg1)->SetDataObject(arg2);
28573
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 Py_INCREF(Py_None); resultobj = Py_None;
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28585 PyObject *resultobj;
28586 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28587 int arg2 ;
28588 int arg3 ;
28589 wxDragResult arg4 ;
28590 wxDragResult result;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 PyObject * obj2 = 0 ;
28594 PyObject * obj3 = 0 ;
28595 char *kwnames[] = {
28596 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28597 };
28598
28599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(1)) SWIG_fail;
28602 {
28603 arg2 = (int)(SWIG_As_int(obj1));
28604 if (SWIG_arg_fail(2)) SWIG_fail;
28605 }
28606 {
28607 arg3 = (int)(SWIG_As_int(obj2));
28608 if (SWIG_arg_fail(3)) SWIG_fail;
28609 }
28610 {
28611 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28612 if (SWIG_arg_fail(4)) SWIG_fail;
28613 }
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 resultobj = SWIG_From_int((result));
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28629 PyObject *resultobj;
28630 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28631 int arg2 ;
28632 int arg3 ;
28633 wxDragResult arg4 ;
28634 wxDragResult result;
28635 PyObject * obj0 = 0 ;
28636 PyObject * obj1 = 0 ;
28637 PyObject * obj2 = 0 ;
28638 PyObject * obj3 = 0 ;
28639 char *kwnames[] = {
28640 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28641 };
28642
28643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28645 if (SWIG_arg_fail(1)) SWIG_fail;
28646 {
28647 arg2 = (int)(SWIG_As_int(obj1));
28648 if (SWIG_arg_fail(2)) SWIG_fail;
28649 }
28650 {
28651 arg3 = (int)(SWIG_As_int(obj2));
28652 if (SWIG_arg_fail(3)) SWIG_fail;
28653 }
28654 {
28655 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28656 if (SWIG_arg_fail(4)) SWIG_fail;
28657 }
28658 {
28659 PyThreadState* __tstate = wxPyBeginAllowThreads();
28660 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28661
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_From_int((result));
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj;
28674 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28675 PyObject * obj0 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 (arg1)->base_OnLeave();
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 Py_INCREF(Py_None); resultobj = Py_None;
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj;
28699 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28700 int arg2 ;
28701 int arg3 ;
28702 bool result;
28703 PyObject * obj0 = 0 ;
28704 PyObject * obj1 = 0 ;
28705 PyObject * obj2 = 0 ;
28706 char *kwnames[] = {
28707 (char *) "self",(char *) "x",(char *) "y", NULL
28708 };
28709
28710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(1)) SWIG_fail;
28713 {
28714 arg2 = (int)(SWIG_As_int(obj1));
28715 if (SWIG_arg_fail(2)) SWIG_fail;
28716 }
28717 {
28718 arg3 = (int)(SWIG_As_int(obj2));
28719 if (SWIG_arg_fail(3)) SWIG_fail;
28720 }
28721 {
28722 PyThreadState* __tstate = wxPyBeginAllowThreads();
28723 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28724
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 {
28729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28730 }
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj;
28739 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28740 bool result;
28741 PyObject * obj0 = 0 ;
28742 char *kwnames[] = {
28743 (char *) "self", NULL
28744 };
28745
28746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28748 if (SWIG_arg_fail(1)) SWIG_fail;
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)(arg1)->GetData();
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28766 PyObject *obj;
28767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28768 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28769 Py_INCREF(obj);
28770 return Py_BuildValue((char *)"");
28771 }
28772 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28773 PyObject *resultobj;
28774 wxPyTextDropTarget *result;
28775 char *kwnames[] = {
28776 NULL
28777 };
28778
28779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28783
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28797 PyObject *arg2 = (PyObject *) 0 ;
28798 PyObject *arg3 = (PyObject *) 0 ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 PyObject * obj2 = 0 ;
28802 char *kwnames[] = {
28803 (char *) "self",(char *) "self",(char *) "_class", NULL
28804 };
28805
28806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28808 if (SWIG_arg_fail(1)) SWIG_fail;
28809 arg2 = obj1;
28810 arg3 = obj2;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 (arg1)->_setCallbackInfo(arg2,arg3);
28814
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 Py_INCREF(Py_None); resultobj = Py_None;
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28826 PyObject *resultobj;
28827 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28828 int arg2 ;
28829 int arg3 ;
28830 wxDragResult arg4 ;
28831 wxDragResult result;
28832 PyObject * obj0 = 0 ;
28833 PyObject * obj1 = 0 ;
28834 PyObject * obj2 = 0 ;
28835 PyObject * obj3 = 0 ;
28836 char *kwnames[] = {
28837 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28838 };
28839
28840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28842 if (SWIG_arg_fail(1)) SWIG_fail;
28843 {
28844 arg2 = (int)(SWIG_As_int(obj1));
28845 if (SWIG_arg_fail(2)) SWIG_fail;
28846 }
28847 {
28848 arg3 = (int)(SWIG_As_int(obj2));
28849 if (SWIG_arg_fail(3)) SWIG_fail;
28850 }
28851 {
28852 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28853 if (SWIG_arg_fail(4)) SWIG_fail;
28854 }
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_From_int((result));
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj;
28871 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28872 int arg2 ;
28873 int arg3 ;
28874 wxDragResult arg4 ;
28875 wxDragResult result;
28876 PyObject * obj0 = 0 ;
28877 PyObject * obj1 = 0 ;
28878 PyObject * obj2 = 0 ;
28879 PyObject * obj3 = 0 ;
28880 char *kwnames[] = {
28881 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28882 };
28883
28884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28886 if (SWIG_arg_fail(1)) SWIG_fail;
28887 {
28888 arg2 = (int)(SWIG_As_int(obj1));
28889 if (SWIG_arg_fail(2)) SWIG_fail;
28890 }
28891 {
28892 arg3 = (int)(SWIG_As_int(obj2));
28893 if (SWIG_arg_fail(3)) SWIG_fail;
28894 }
28895 {
28896 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28897 if (SWIG_arg_fail(4)) SWIG_fail;
28898 }
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28902
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_From_int((result));
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28914 PyObject *resultobj;
28915 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28916 PyObject * obj0 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 (arg1)->base_OnLeave();
28927
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 Py_INCREF(Py_None); resultobj = Py_None;
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj;
28940 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28941 int arg2 ;
28942 int arg3 ;
28943 bool result;
28944 PyObject * obj0 = 0 ;
28945 PyObject * obj1 = 0 ;
28946 PyObject * obj2 = 0 ;
28947 char *kwnames[] = {
28948 (char *) "self",(char *) "x",(char *) "y", NULL
28949 };
28950
28951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28953 if (SWIG_arg_fail(1)) SWIG_fail;
28954 {
28955 arg2 = (int)(SWIG_As_int(obj1));
28956 if (SWIG_arg_fail(2)) SWIG_fail;
28957 }
28958 {
28959 arg3 = (int)(SWIG_As_int(obj2));
28960 if (SWIG_arg_fail(3)) SWIG_fail;
28961 }
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28965
28966 wxPyEndAllowThreads(__tstate);
28967 if (PyErr_Occurred()) SWIG_fail;
28968 }
28969 {
28970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28971 }
28972 return resultobj;
28973 fail:
28974 return NULL;
28975 }
28976
28977
28978 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj;
28980 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28981 int arg2 ;
28982 int arg3 ;
28983 wxDragResult arg4 ;
28984 wxDragResult result;
28985 PyObject * obj0 = 0 ;
28986 PyObject * obj1 = 0 ;
28987 PyObject * obj2 = 0 ;
28988 PyObject * obj3 = 0 ;
28989 char *kwnames[] = {
28990 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28991 };
28992
28993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28995 if (SWIG_arg_fail(1)) SWIG_fail;
28996 {
28997 arg2 = (int)(SWIG_As_int(obj1));
28998 if (SWIG_arg_fail(2)) SWIG_fail;
28999 }
29000 {
29001 arg3 = (int)(SWIG_As_int(obj2));
29002 if (SWIG_arg_fail(3)) SWIG_fail;
29003 }
29004 {
29005 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29006 if (SWIG_arg_fail(4)) SWIG_fail;
29007 }
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29011
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 resultobj = SWIG_From_int((result));
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29023 PyObject *obj;
29024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29025 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29026 Py_INCREF(obj);
29027 return Py_BuildValue((char *)"");
29028 }
29029 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29030 PyObject *resultobj;
29031 wxPyFileDropTarget *result;
29032 char *kwnames[] = {
29033 NULL
29034 };
29035
29036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29040
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29052 PyObject *resultobj;
29053 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29054 PyObject *arg2 = (PyObject *) 0 ;
29055 PyObject *arg3 = (PyObject *) 0 ;
29056 PyObject * obj0 = 0 ;
29057 PyObject * obj1 = 0 ;
29058 PyObject * obj2 = 0 ;
29059 char *kwnames[] = {
29060 (char *) "self",(char *) "self",(char *) "_class", NULL
29061 };
29062
29063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29065 if (SWIG_arg_fail(1)) SWIG_fail;
29066 arg2 = obj1;
29067 arg3 = obj2;
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 (arg1)->_setCallbackInfo(arg2,arg3);
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 Py_INCREF(Py_None); resultobj = Py_None;
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29083 PyObject *resultobj;
29084 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29085 int arg2 ;
29086 int arg3 ;
29087 wxDragResult arg4 ;
29088 wxDragResult result;
29089 PyObject * obj0 = 0 ;
29090 PyObject * obj1 = 0 ;
29091 PyObject * obj2 = 0 ;
29092 PyObject * obj3 = 0 ;
29093 char *kwnames[] = {
29094 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29095 };
29096
29097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29099 if (SWIG_arg_fail(1)) SWIG_fail;
29100 {
29101 arg2 = (int)(SWIG_As_int(obj1));
29102 if (SWIG_arg_fail(2)) SWIG_fail;
29103 }
29104 {
29105 arg3 = (int)(SWIG_As_int(obj2));
29106 if (SWIG_arg_fail(3)) SWIG_fail;
29107 }
29108 {
29109 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29110 if (SWIG_arg_fail(4)) SWIG_fail;
29111 }
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29115
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_From_int((result));
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj;
29128 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29129 int arg2 ;
29130 int arg3 ;
29131 wxDragResult arg4 ;
29132 wxDragResult result;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 PyObject * obj2 = 0 ;
29136 PyObject * obj3 = 0 ;
29137 char *kwnames[] = {
29138 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29139 };
29140
29141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29143 if (SWIG_arg_fail(1)) SWIG_fail;
29144 {
29145 arg2 = (int)(SWIG_As_int(obj1));
29146 if (SWIG_arg_fail(2)) SWIG_fail;
29147 }
29148 {
29149 arg3 = (int)(SWIG_As_int(obj2));
29150 if (SWIG_arg_fail(3)) SWIG_fail;
29151 }
29152 {
29153 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29154 if (SWIG_arg_fail(4)) SWIG_fail;
29155 }
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29159
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 resultobj = SWIG_From_int((result));
29164 return resultobj;
29165 fail:
29166 return NULL;
29167 }
29168
29169
29170 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29171 PyObject *resultobj;
29172 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29173 PyObject * obj0 = 0 ;
29174 char *kwnames[] = {
29175 (char *) "self", NULL
29176 };
29177
29178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29180 if (SWIG_arg_fail(1)) SWIG_fail;
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 (arg1)->base_OnLeave();
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 Py_INCREF(Py_None); resultobj = Py_None;
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj;
29197 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29198 int arg2 ;
29199 int arg3 ;
29200 bool result;
29201 PyObject * obj0 = 0 ;
29202 PyObject * obj1 = 0 ;
29203 PyObject * obj2 = 0 ;
29204 char *kwnames[] = {
29205 (char *) "self",(char *) "x",(char *) "y", NULL
29206 };
29207
29208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29210 if (SWIG_arg_fail(1)) SWIG_fail;
29211 {
29212 arg2 = (int)(SWIG_As_int(obj1));
29213 if (SWIG_arg_fail(2)) SWIG_fail;
29214 }
29215 {
29216 arg3 = (int)(SWIG_As_int(obj2));
29217 if (SWIG_arg_fail(3)) SWIG_fail;
29218 }
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29222
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 {
29227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29228 }
29229 return resultobj;
29230 fail:
29231 return NULL;
29232 }
29233
29234
29235 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29236 PyObject *resultobj;
29237 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29238 int arg2 ;
29239 int arg3 ;
29240 wxDragResult arg4 ;
29241 wxDragResult result;
29242 PyObject * obj0 = 0 ;
29243 PyObject * obj1 = 0 ;
29244 PyObject * obj2 = 0 ;
29245 PyObject * obj3 = 0 ;
29246 char *kwnames[] = {
29247 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29248 };
29249
29250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29252 if (SWIG_arg_fail(1)) SWIG_fail;
29253 {
29254 arg2 = (int)(SWIG_As_int(obj1));
29255 if (SWIG_arg_fail(2)) SWIG_fail;
29256 }
29257 {
29258 arg3 = (int)(SWIG_As_int(obj2));
29259 if (SWIG_arg_fail(3)) SWIG_fail;
29260 }
29261 {
29262 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29263 if (SWIG_arg_fail(4)) SWIG_fail;
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29268
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_From_int((result));
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29280 PyObject *obj;
29281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29282 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29283 Py_INCREF(obj);
29284 return Py_BuildValue((char *)"");
29285 }
29286 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj;
29288 wxClipboard *result;
29289 char *kwnames[] = {
29290 NULL
29291 };
29292
29293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 result = (wxClipboard *)new wxClipboard();
29297
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29302 return resultobj;
29303 fail:
29304 return NULL;
29305 }
29306
29307
29308 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj;
29310 wxClipboard *arg1 = (wxClipboard *) 0 ;
29311 PyObject * obj0 = 0 ;
29312 char *kwnames[] = {
29313 (char *) "self", NULL
29314 };
29315
29316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29318 if (SWIG_arg_fail(1)) SWIG_fail;
29319 {
29320 PyThreadState* __tstate = wxPyBeginAllowThreads();
29321 delete arg1;
29322
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 Py_INCREF(Py_None); resultobj = Py_None;
29327 return resultobj;
29328 fail:
29329 return NULL;
29330 }
29331
29332
29333 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29334 PyObject *resultobj;
29335 wxClipboard *arg1 = (wxClipboard *) 0 ;
29336 bool result;
29337 PyObject * obj0 = 0 ;
29338 char *kwnames[] = {
29339 (char *) "self", NULL
29340 };
29341
29342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29344 if (SWIG_arg_fail(1)) SWIG_fail;
29345 {
29346 PyThreadState* __tstate = wxPyBeginAllowThreads();
29347 result = (bool)(arg1)->Open();
29348
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 {
29353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29354 }
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29362 PyObject *resultobj;
29363 wxClipboard *arg1 = (wxClipboard *) 0 ;
29364 PyObject * obj0 = 0 ;
29365 char *kwnames[] = {
29366 (char *) "self", NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29371 if (SWIG_arg_fail(1)) SWIG_fail;
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 (arg1)->Close();
29375
29376 wxPyEndAllowThreads(__tstate);
29377 if (PyErr_Occurred()) SWIG_fail;
29378 }
29379 Py_INCREF(Py_None); resultobj = Py_None;
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj;
29388 wxClipboard *arg1 = (wxClipboard *) 0 ;
29389 bool result;
29390 PyObject * obj0 = 0 ;
29391 char *kwnames[] = {
29392 (char *) "self", NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(1)) SWIG_fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 {
29406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29407 }
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29415 PyObject *resultobj;
29416 wxClipboard *arg1 = (wxClipboard *) 0 ;
29417 wxDataObject *arg2 = (wxDataObject *) 0 ;
29418 bool result;
29419 PyObject * obj0 = 0 ;
29420 PyObject * obj1 = 0 ;
29421 char *kwnames[] = {
29422 (char *) "self",(char *) "data", NULL
29423 };
29424
29425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29427 if (SWIG_arg_fail(1)) SWIG_fail;
29428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29429 if (SWIG_arg_fail(2)) SWIG_fail;
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)(arg1)->AddData(arg2);
29433
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj;
29448 wxClipboard *arg1 = (wxClipboard *) 0 ;
29449 wxDataObject *arg2 = (wxDataObject *) 0 ;
29450 bool result;
29451 PyObject * obj0 = 0 ;
29452 PyObject * obj1 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self",(char *) "data", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29461 if (SWIG_arg_fail(2)) SWIG_fail;
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 result = (bool)(arg1)->SetData(arg2);
29465
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 {
29470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29471 }
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj;
29480 wxClipboard *arg1 = (wxClipboard *) 0 ;
29481 wxDataFormat *arg2 = 0 ;
29482 bool result;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char *kwnames[] = {
29486 (char *) "self",(char *) "format", NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(1)) SWIG_fail;
29492 {
29493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29494 if (SWIG_arg_fail(2)) SWIG_fail;
29495 if (arg2 == NULL) {
29496 SWIG_null_ref("wxDataFormat");
29497 }
29498 if (SWIG_arg_fail(2)) SWIG_fail;
29499 }
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29503
29504 wxPyEndAllowThreads(__tstate);
29505 if (PyErr_Occurred()) SWIG_fail;
29506 }
29507 {
29508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29509 }
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj;
29518 wxClipboard *arg1 = (wxClipboard *) 0 ;
29519 wxDataObject *arg2 = 0 ;
29520 bool result;
29521 PyObject * obj0 = 0 ;
29522 PyObject * obj1 = 0 ;
29523 char *kwnames[] = {
29524 (char *) "self",(char *) "data", NULL
29525 };
29526
29527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29529 if (SWIG_arg_fail(1)) SWIG_fail;
29530 {
29531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29532 if (SWIG_arg_fail(2)) SWIG_fail;
29533 if (arg2 == NULL) {
29534 SWIG_null_ref("wxDataObject");
29535 }
29536 if (SWIG_arg_fail(2)) SWIG_fail;
29537 }
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (bool)(arg1)->GetData(*arg2);
29541
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 {
29546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29547 }
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj;
29556 wxClipboard *arg1 = (wxClipboard *) 0 ;
29557 PyObject * obj0 = 0 ;
29558 char *kwnames[] = {
29559 (char *) "self", NULL
29560 };
29561
29562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29564 if (SWIG_arg_fail(1)) SWIG_fail;
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 (arg1)->Clear();
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 Py_INCREF(Py_None); resultobj = Py_None;
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj;
29581 wxClipboard *arg1 = (wxClipboard *) 0 ;
29582 bool result;
29583 PyObject * obj0 = 0 ;
29584 char *kwnames[] = {
29585 (char *) "self", NULL
29586 };
29587
29588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29590 if (SWIG_arg_fail(1)) SWIG_fail;
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = (bool)(arg1)->Flush();
29594
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 {
29599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29600 }
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj;
29609 wxClipboard *arg1 = (wxClipboard *) 0 ;
29610 bool arg2 = (bool) true ;
29611 PyObject * obj0 = 0 ;
29612 PyObject * obj1 = 0 ;
29613 char *kwnames[] = {
29614 (char *) "self",(char *) "primary", NULL
29615 };
29616
29617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29619 if (SWIG_arg_fail(1)) SWIG_fail;
29620 if (obj1) {
29621 {
29622 arg2 = (bool)(SWIG_As_bool(obj1));
29623 if (SWIG_arg_fail(2)) SWIG_fail;
29624 }
29625 }
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 (arg1)->UsePrimarySelection(arg2);
29629
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 Py_INCREF(Py_None); resultobj = Py_None;
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29641 PyObject *resultobj;
29642 wxClipboard *result;
29643 char *kwnames[] = {
29644 NULL
29645 };
29646
29647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (wxClipboard *)wxClipboard::Get();
29651
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29663 PyObject *obj;
29664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29665 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29666 Py_INCREF(obj);
29667 return Py_BuildValue((char *)"");
29668 }
29669 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj;
29671 wxClipboard *arg1 = (wxClipboard *) NULL ;
29672 wxClipboardLocker *result;
29673 PyObject * obj0 = 0 ;
29674 char *kwnames[] = {
29675 (char *) "clipboard", NULL
29676 };
29677
29678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29679 if (obj0) {
29680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29681 if (SWIG_arg_fail(1)) SWIG_fail;
29682 }
29683 {
29684 PyThreadState* __tstate = wxPyBeginAllowThreads();
29685 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29686
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj;
29699 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29700 PyObject * obj0 = 0 ;
29701 char *kwnames[] = {
29702 (char *) "self", NULL
29703 };
29704
29705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29707 if (SWIG_arg_fail(1)) SWIG_fail;
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 delete arg1;
29711
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 Py_INCREF(Py_None); resultobj = Py_None;
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj;
29724 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29725 bool result;
29726 PyObject * obj0 = 0 ;
29727 char *kwnames[] = {
29728 (char *) "self", NULL
29729 };
29730
29731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29733 if (SWIG_arg_fail(1)) SWIG_fail;
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (bool)wxClipboardLocker___nonzero__(arg1);
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29751 PyObject *obj;
29752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29753 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29754 Py_INCREF(obj);
29755 return Py_BuildValue((char *)"");
29756 }
29757 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj;
29759 int arg1 = (int) 0 ;
29760 int arg2 = (int) 0 ;
29761 int arg3 = (int) 0 ;
29762 int arg4 = (int) 0 ;
29763 wxVideoMode *result;
29764 PyObject * obj0 = 0 ;
29765 PyObject * obj1 = 0 ;
29766 PyObject * obj2 = 0 ;
29767 PyObject * obj3 = 0 ;
29768 char *kwnames[] = {
29769 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29770 };
29771
29772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29773 if (obj0) {
29774 {
29775 arg1 = (int)(SWIG_As_int(obj0));
29776 if (SWIG_arg_fail(1)) SWIG_fail;
29777 }
29778 }
29779 if (obj1) {
29780 {
29781 arg2 = (int)(SWIG_As_int(obj1));
29782 if (SWIG_arg_fail(2)) SWIG_fail;
29783 }
29784 }
29785 if (obj2) {
29786 {
29787 arg3 = (int)(SWIG_As_int(obj2));
29788 if (SWIG_arg_fail(3)) SWIG_fail;
29789 }
29790 }
29791 if (obj3) {
29792 {
29793 arg4 = (int)(SWIG_As_int(obj3));
29794 if (SWIG_arg_fail(4)) SWIG_fail;
29795 }
29796 }
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29800
29801 wxPyEndAllowThreads(__tstate);
29802 if (PyErr_Occurred()) SWIG_fail;
29803 }
29804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29805 return resultobj;
29806 fail:
29807 return NULL;
29808 }
29809
29810
29811 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj;
29813 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29814 PyObject * obj0 = 0 ;
29815 char *kwnames[] = {
29816 (char *) "self", NULL
29817 };
29818
29819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29821 if (SWIG_arg_fail(1)) SWIG_fail;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 delete arg1;
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 Py_INCREF(Py_None); resultobj = Py_None;
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj;
29838 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29839 wxVideoMode *arg2 = 0 ;
29840 bool result;
29841 PyObject * obj0 = 0 ;
29842 PyObject * obj1 = 0 ;
29843 char *kwnames[] = {
29844 (char *) "self",(char *) "other", NULL
29845 };
29846
29847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29849 if (SWIG_arg_fail(1)) SWIG_fail;
29850 {
29851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29852 if (SWIG_arg_fail(2)) SWIG_fail;
29853 if (arg2 == NULL) {
29854 SWIG_null_ref("wxVideoMode");
29855 }
29856 if (SWIG_arg_fail(2)) SWIG_fail;
29857 }
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*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_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj;
29876 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29877 int result;
29878 PyObject * obj0 = 0 ;
29879 char *kwnames[] = {
29880 (char *) "self", NULL
29881 };
29882
29883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29885 if (SWIG_arg_fail(1)) SWIG_fail;
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29889
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 {
29894 resultobj = SWIG_From_int((int)(result));
29895 }
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29903 PyObject *resultobj;
29904 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29905 int result;
29906 PyObject * obj0 = 0 ;
29907 char *kwnames[] = {
29908 (char *) "self", NULL
29909 };
29910
29911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29913 if (SWIG_arg_fail(1)) SWIG_fail;
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29917
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = SWIG_From_int((int)(result));
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29931 PyObject *resultobj;
29932 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29933 int result;
29934 PyObject * obj0 = 0 ;
29935 char *kwnames[] = {
29936 (char *) "self", NULL
29937 };
29938
29939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29941 if (SWIG_arg_fail(1)) SWIG_fail;
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29945
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 {
29950 resultobj = SWIG_From_int((int)(result));
29951 }
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29959 PyObject *resultobj;
29960 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29961 bool result;
29962 PyObject * obj0 = 0 ;
29963 char *kwnames[] = {
29964 (char *) "self", NULL
29965 };
29966
29967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29969 if (SWIG_arg_fail(1)) SWIG_fail;
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29973
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 {
29978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29979 }
29980 return resultobj;
29981 fail:
29982 return NULL;
29983 }
29984
29985
29986 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj;
29988 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29989 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29990 bool result;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 char *kwnames[] = {
29994 (char *) "self",(char *) "other", NULL
29995 };
29996
29997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29999 if (SWIG_arg_fail(1)) SWIG_fail;
30000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(2)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj;
30020 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30021 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30022 bool result;
30023 PyObject * obj0 = 0 ;
30024 PyObject * obj1 = 0 ;
30025 char *kwnames[] = {
30026 (char *) "self",(char *) "other", NULL
30027 };
30028
30029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30031 if (SWIG_arg_fail(1)) SWIG_fail;
30032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30037
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 {
30042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30043 }
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj;
30052 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30053 int arg2 ;
30054 PyObject * obj0 = 0 ;
30055 PyObject * obj1 = 0 ;
30056 char *kwnames[] = {
30057 (char *) "self",(char *) "w", NULL
30058 };
30059
30060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(1)) SWIG_fail;
30063 {
30064 arg2 = (int)(SWIG_As_int(obj1));
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 }
30067 if (arg1) (arg1)->w = arg2;
30068
30069 Py_INCREF(Py_None); resultobj = Py_None;
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30077 PyObject *resultobj;
30078 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30079 int result;
30080 PyObject * obj0 = 0 ;
30081 char *kwnames[] = {
30082 (char *) "self", NULL
30083 };
30084
30085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30087 if (SWIG_arg_fail(1)) SWIG_fail;
30088 result = (int) ((arg1)->w);
30089
30090 {
30091 resultobj = SWIG_From_int((int)(result));
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj;
30101 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30102 int arg2 ;
30103 PyObject * obj0 = 0 ;
30104 PyObject * obj1 = 0 ;
30105 char *kwnames[] = {
30106 (char *) "self",(char *) "h", NULL
30107 };
30108
30109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30111 if (SWIG_arg_fail(1)) SWIG_fail;
30112 {
30113 arg2 = (int)(SWIG_As_int(obj1));
30114 if (SWIG_arg_fail(2)) SWIG_fail;
30115 }
30116 if (arg1) (arg1)->h = arg2;
30117
30118 Py_INCREF(Py_None); resultobj = Py_None;
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj;
30127 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30128 int result;
30129 PyObject * obj0 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 result = (int) ((arg1)->h);
30138
30139 {
30140 resultobj = SWIG_From_int((int)(result));
30141 }
30142 return resultobj;
30143 fail:
30144 return NULL;
30145 }
30146
30147
30148 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30149 PyObject *resultobj;
30150 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30151 int arg2 ;
30152 PyObject * obj0 = 0 ;
30153 PyObject * obj1 = 0 ;
30154 char *kwnames[] = {
30155 (char *) "self",(char *) "bpp", NULL
30156 };
30157
30158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30160 if (SWIG_arg_fail(1)) SWIG_fail;
30161 {
30162 arg2 = (int)(SWIG_As_int(obj1));
30163 if (SWIG_arg_fail(2)) SWIG_fail;
30164 }
30165 if (arg1) (arg1)->bpp = arg2;
30166
30167 Py_INCREF(Py_None); resultobj = Py_None;
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj;
30176 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30177 int result;
30178 PyObject * obj0 = 0 ;
30179 char *kwnames[] = {
30180 (char *) "self", NULL
30181 };
30182
30183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(1)) SWIG_fail;
30186 result = (int) ((arg1)->bpp);
30187
30188 {
30189 resultobj = SWIG_From_int((int)(result));
30190 }
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj;
30199 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30200 int arg2 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char *kwnames[] = {
30204 (char *) "self",(char *) "refresh", NULL
30205 };
30206
30207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30209 if (SWIG_arg_fail(1)) SWIG_fail;
30210 {
30211 arg2 = (int)(SWIG_As_int(obj1));
30212 if (SWIG_arg_fail(2)) SWIG_fail;
30213 }
30214 if (arg1) (arg1)->refresh = arg2;
30215
30216 Py_INCREF(Py_None); resultobj = Py_None;
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30224 PyObject *resultobj;
30225 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30226 int result;
30227 PyObject * obj0 = 0 ;
30228 char *kwnames[] = {
30229 (char *) "self", NULL
30230 };
30231
30232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30234 if (SWIG_arg_fail(1)) SWIG_fail;
30235 result = (int) ((arg1)->refresh);
30236
30237 {
30238 resultobj = SWIG_From_int((int)(result));
30239 }
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30247 PyObject *obj;
30248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30249 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30250 Py_INCREF(obj);
30251 return Py_BuildValue((char *)"");
30252 }
30253 static int _wrap_DefaultVideoMode_set(PyObject *) {
30254 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30255 return 1;
30256 }
30257
30258
30259 static PyObject *_wrap_DefaultVideoMode_get(void) {
30260 PyObject *pyobj;
30261
30262 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30263 return pyobj;
30264 }
30265
30266
30267 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj;
30269 size_t arg1 = (size_t) 0 ;
30270 wxDisplay *result;
30271 PyObject * obj0 = 0 ;
30272 char *kwnames[] = {
30273 (char *) "index", NULL
30274 };
30275
30276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30277 if (obj0) {
30278 {
30279 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30280 if (SWIG_arg_fail(1)) SWIG_fail;
30281 }
30282 }
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 result = (wxDisplay *)new wxDisplay(arg1);
30286
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30291 return resultobj;
30292 fail:
30293 return NULL;
30294 }
30295
30296
30297 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30298 PyObject *resultobj;
30299 wxDisplay *arg1 = (wxDisplay *) 0 ;
30300 PyObject * obj0 = 0 ;
30301 char *kwnames[] = {
30302 (char *) "self", NULL
30303 };
30304
30305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30307 if (SWIG_arg_fail(1)) SWIG_fail;
30308 {
30309 PyThreadState* __tstate = wxPyBeginAllowThreads();
30310 delete arg1;
30311
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 Py_INCREF(Py_None); resultobj = Py_None;
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30323 PyObject *resultobj;
30324 size_t result;
30325 char *kwnames[] = {
30326 NULL
30327 };
30328
30329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30330 {
30331 PyThreadState* __tstate = wxPyBeginAllowThreads();
30332 result = (size_t)wxDisplay::GetCount();
30333
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 {
30338 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30339 }
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30347 PyObject *resultobj;
30348 wxPoint *arg1 = 0 ;
30349 int result;
30350 wxPoint temp1 ;
30351 PyObject * obj0 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "pt", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30357 {
30358 arg1 = &temp1;
30359 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30360 }
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 {
30369 resultobj = SWIG_From_int((int)(result));
30370 }
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj;
30379 wxWindow *arg1 = (wxWindow *) 0 ;
30380 int result;
30381 PyObject * obj0 = 0 ;
30382 char *kwnames[] = {
30383 (char *) "window", NULL
30384 };
30385
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 result = (int)wxDisplay::GetFromWindow(arg1);
30392
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 {
30397 resultobj = SWIG_From_int((int)(result));
30398 }
30399 return resultobj;
30400 fail:
30401 return NULL;
30402 }
30403
30404
30405 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30406 PyObject *resultobj;
30407 wxDisplay *arg1 = (wxDisplay *) 0 ;
30408 bool result;
30409 PyObject * obj0 = 0 ;
30410 char *kwnames[] = {
30411 (char *) "self", NULL
30412 };
30413
30414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30416 if (SWIG_arg_fail(1)) SWIG_fail;
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 result = (bool)((wxDisplay const *)arg1)->IsOk();
30420
30421 wxPyEndAllowThreads(__tstate);
30422 if (PyErr_Occurred()) SWIG_fail;
30423 }
30424 {
30425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30426 }
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj;
30435 wxDisplay *arg1 = (wxDisplay *) 0 ;
30436 wxRect result;
30437 PyObject * obj0 = 0 ;
30438 char *kwnames[] = {
30439 (char *) "self", NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30444 if (SWIG_arg_fail(1)) SWIG_fail;
30445 {
30446 PyThreadState* __tstate = wxPyBeginAllowThreads();
30447 result = ((wxDisplay const *)arg1)->GetGeometry();
30448
30449 wxPyEndAllowThreads(__tstate);
30450 if (PyErr_Occurred()) SWIG_fail;
30451 }
30452 {
30453 wxRect * resultptr;
30454 resultptr = new wxRect((wxRect &)(result));
30455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30456 }
30457 return resultobj;
30458 fail:
30459 return NULL;
30460 }
30461
30462
30463 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30464 PyObject *resultobj;
30465 wxDisplay *arg1 = (wxDisplay *) 0 ;
30466 wxString result;
30467 PyObject * obj0 = 0 ;
30468 char *kwnames[] = {
30469 (char *) "self", NULL
30470 };
30471
30472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30474 if (SWIG_arg_fail(1)) SWIG_fail;
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = ((wxDisplay const *)arg1)->GetName();
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 {
30483 #if wxUSE_UNICODE
30484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30485 #else
30486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30487 #endif
30488 }
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj;
30497 wxDisplay *arg1 = (wxDisplay *) 0 ;
30498 bool result;
30499 PyObject * obj0 = 0 ;
30500 char *kwnames[] = {
30501 (char *) "self", NULL
30502 };
30503
30504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30506 if (SWIG_arg_fail(1)) SWIG_fail;
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30510
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 {
30515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30516 }
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30524 PyObject *resultobj;
30525 wxDisplay *arg1 = (wxDisplay *) 0 ;
30526 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30527 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30528 PyObject *result;
30529 PyObject * obj0 = 0 ;
30530 PyObject * obj1 = 0 ;
30531 char *kwnames[] = {
30532 (char *) "self",(char *) "mode", NULL
30533 };
30534
30535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30537 if (SWIG_arg_fail(1)) SWIG_fail;
30538 if (obj1) {
30539 {
30540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30541 if (SWIG_arg_fail(2)) SWIG_fail;
30542 if (arg2 == NULL) {
30543 SWIG_null_ref("wxVideoMode");
30544 }
30545 if (SWIG_arg_fail(2)) SWIG_fail;
30546 }
30547 }
30548 {
30549 PyThreadState* __tstate = wxPyBeginAllowThreads();
30550 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30551
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 resultobj = result;
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj;
30564 wxDisplay *arg1 = (wxDisplay *) 0 ;
30565 wxVideoMode result;
30566 PyObject * obj0 = 0 ;
30567 char *kwnames[] = {
30568 (char *) "self", NULL
30569 };
30570
30571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30573 if (SWIG_arg_fail(1)) SWIG_fail;
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30577
30578 wxPyEndAllowThreads(__tstate);
30579 if (PyErr_Occurred()) SWIG_fail;
30580 }
30581 {
30582 wxVideoMode * resultptr;
30583 resultptr = new wxVideoMode((wxVideoMode &)(result));
30584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30585 }
30586 return resultobj;
30587 fail:
30588 return NULL;
30589 }
30590
30591
30592 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30593 PyObject *resultobj;
30594 wxDisplay *arg1 = (wxDisplay *) 0 ;
30595 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30596 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30597 bool result;
30598 PyObject * obj0 = 0 ;
30599 PyObject * obj1 = 0 ;
30600 char *kwnames[] = {
30601 (char *) "self",(char *) "mode", NULL
30602 };
30603
30604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30606 if (SWIG_arg_fail(1)) SWIG_fail;
30607 if (obj1) {
30608 {
30609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30610 if (SWIG_arg_fail(2)) SWIG_fail;
30611 if (arg2 == NULL) {
30612 SWIG_null_ref("wxVideoMode");
30613 }
30614 if (SWIG_arg_fail(2)) SWIG_fail;
30615 }
30616 }
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 {
30625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30626 }
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj;
30635 wxDisplay *arg1 = (wxDisplay *) 0 ;
30636 PyObject * obj0 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 (arg1)->ResetMode();
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 Py_INCREF(Py_None); resultobj = Py_None;
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30659 PyObject *obj;
30660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30661 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30662 Py_INCREF(obj);
30663 return Py_BuildValue((char *)"");
30664 }
30665 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30666 PyObject *resultobj;
30667 wxStandardPaths *result;
30668 char *kwnames[] = {
30669 NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = (wxStandardPaths *)StandardPaths_Get();
30676
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj;
30689 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30690 wxString result;
30691 PyObject * obj0 = 0 ;
30692 char *kwnames[] = {
30693 (char *) "self", NULL
30694 };
30695
30696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30698 if (SWIG_arg_fail(1)) SWIG_fail;
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30702
30703 wxPyEndAllowThreads(__tstate);
30704 if (PyErr_Occurred()) SWIG_fail;
30705 }
30706 {
30707 #if wxUSE_UNICODE
30708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30709 #else
30710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30711 #endif
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj;
30721 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30722 wxString result;
30723 PyObject * obj0 = 0 ;
30724 char *kwnames[] = {
30725 (char *) "self", NULL
30726 };
30727
30728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30734
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 {
30739 #if wxUSE_UNICODE
30740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30741 #else
30742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30743 #endif
30744 }
30745 return resultobj;
30746 fail:
30747 return NULL;
30748 }
30749
30750
30751 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30752 PyObject *resultobj;
30753 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30754 wxString result;
30755 PyObject * obj0 = 0 ;
30756 char *kwnames[] = {
30757 (char *) "self", NULL
30758 };
30759
30760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30762 if (SWIG_arg_fail(1)) SWIG_fail;
30763 {
30764 PyThreadState* __tstate = wxPyBeginAllowThreads();
30765 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30766
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 {
30771 #if wxUSE_UNICODE
30772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30773 #else
30774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30775 #endif
30776 }
30777 return resultobj;
30778 fail:
30779 return NULL;
30780 }
30781
30782
30783 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30784 PyObject *resultobj;
30785 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30786 wxString result;
30787 PyObject * obj0 = 0 ;
30788 char *kwnames[] = {
30789 (char *) "self", NULL
30790 };
30791
30792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30794 if (SWIG_arg_fail(1)) SWIG_fail;
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30798
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 {
30803 #if wxUSE_UNICODE
30804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30805 #else
30806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30807 #endif
30808 }
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30818 wxString result;
30819 PyObject * obj0 = 0 ;
30820 char *kwnames[] = {
30821 (char *) "self", NULL
30822 };
30823
30824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30826 if (SWIG_arg_fail(1)) SWIG_fail;
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 {
30835 #if wxUSE_UNICODE
30836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30837 #else
30838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30839 #endif
30840 }
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30848 PyObject *resultobj;
30849 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30850 wxString result;
30851 PyObject * obj0 = 0 ;
30852 char *kwnames[] = {
30853 (char *) "self", NULL
30854 };
30855
30856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30858 if (SWIG_arg_fail(1)) SWIG_fail;
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30862
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 {
30867 #if wxUSE_UNICODE
30868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30869 #else
30870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30871 #endif
30872 }
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj;
30881 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30882 wxString result;
30883 PyObject * obj0 = 0 ;
30884 char *kwnames[] = {
30885 (char *) "self", NULL
30886 };
30887
30888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30890 if (SWIG_arg_fail(1)) SWIG_fail;
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30894
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 {
30899 #if wxUSE_UNICODE
30900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30901 #else
30902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30903 #endif
30904 }
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj;
30913 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30914 wxString *arg2 = 0 ;
30915 bool temp2 = false ;
30916 PyObject * obj0 = 0 ;
30917 PyObject * obj1 = 0 ;
30918 char *kwnames[] = {
30919 (char *) "self",(char *) "prefix", NULL
30920 };
30921
30922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30924 if (SWIG_arg_fail(1)) SWIG_fail;
30925 {
30926 arg2 = wxString_in_helper(obj1);
30927 if (arg2 == NULL) SWIG_fail;
30928 temp2 = true;
30929 }
30930 {
30931 PyThreadState* __tstate = wxPyBeginAllowThreads();
30932 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
30933
30934 wxPyEndAllowThreads(__tstate);
30935 if (PyErr_Occurred()) SWIG_fail;
30936 }
30937 Py_INCREF(Py_None); resultobj = Py_None;
30938 {
30939 if (temp2)
30940 delete arg2;
30941 }
30942 return resultobj;
30943 fail:
30944 {
30945 if (temp2)
30946 delete arg2;
30947 }
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30955 wxString result;
30956 PyObject * obj0 = 0 ;
30957 char *kwnames[] = {
30958 (char *) "self", NULL
30959 };
30960
30961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30963 if (SWIG_arg_fail(1)) SWIG_fail;
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = wxStandardPaths_GetInstallPrefix(arg1);
30967
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 {
30972 #if wxUSE_UNICODE
30973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30974 #else
30975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30976 #endif
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30985 PyObject *obj;
30986 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30987 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30988 Py_INCREF(obj);
30989 return Py_BuildValue((char *)"");
30990 }
30991 static PyMethodDef SwigMethods[] = {
30992 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30993 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30999 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31000 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31006 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31043 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31070 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31078 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31094 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31099 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31102 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31105 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31111 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31125 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31131 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31136 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31139 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31153 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31156 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31157 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31160 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31187 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31189 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31191 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31193 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31200 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31206 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31220 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31224 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31227 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31244 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31252 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31299 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31317 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31327 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31343 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31359 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31373 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31382 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31425 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31428 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31431 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31435 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31528 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31529 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31530 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31531 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31548 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31593 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31627 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31635 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31636 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31641 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31650 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31657 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31660 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31663 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31671 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31675 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31678 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31682 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31683 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31687 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31691 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31695 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31705 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31716 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31732 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31746 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31750 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31768 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31782 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31793 { NULL, NULL, 0, NULL }
31794 };
31795
31796
31797 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31798
31799 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31800 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31801 }
31802 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31803 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31804 }
31805 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31806 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31807 }
31808 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31809 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31810 }
31811 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31812 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31813 }
31814 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31815 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31816 }
31817 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31818 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31819 }
31820 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31821 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31822 }
31823 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31824 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31825 }
31826 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31827 return (void *)((wxEvent *) ((wxPyEvent *) x));
31828 }
31829 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31830 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31831 }
31832 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31833 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31834 }
31835 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31836 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31837 }
31838 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31839 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31840 }
31841 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31842 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31843 }
31844 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31845 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31846 }
31847 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31848 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31849 }
31850 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31851 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31852 }
31853 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31854 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31855 }
31856 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31857 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31858 }
31859 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31860 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31861 }
31862 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31863 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31864 }
31865 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31866 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31867 }
31868 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31869 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31870 }
31871 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31872 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31873 }
31874 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31875 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31876 }
31877 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31878 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31879 }
31880 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31881 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31882 }
31883 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31884 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31885 }
31886 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31887 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31888 }
31889 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31890 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31891 }
31892 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31893 return (void *)((wxEvent *) ((wxShowEvent *) x));
31894 }
31895 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31896 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31897 }
31898 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31899 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31900 }
31901 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31902 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31903 }
31904 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31905 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31906 }
31907 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31908 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31909 }
31910 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31911 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31912 }
31913 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31914 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31915 }
31916 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31917 return (void *)((wxConfigBase *) ((wxConfig *) x));
31918 }
31919 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31920 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31921 }
31922 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31923 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31924 }
31925 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31926 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31927 }
31928 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31929 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31930 }
31931 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31932 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31933 }
31934 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31935 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31936 }
31937 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31938 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31939 }
31940 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31941 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31942 }
31943 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31944 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31945 }
31946 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31947 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31948 }
31949 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31950 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31951 }
31952 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31953 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31954 }
31955 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31956 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31957 }
31958 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31959 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31960 }
31961 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31962 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31963 }
31964 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31965 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31966 }
31967 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31968 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31969 }
31970 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31971 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31972 }
31973 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31974 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31975 }
31976 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31977 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31978 }
31979 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31980 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31981 }
31982 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31983 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31984 }
31985 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31986 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31987 }
31988 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31989 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31990 }
31991 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31992 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31993 }
31994 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31995 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31996 }
31997 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31998 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31999 }
32000 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32001 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32002 }
32003 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32004 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32005 }
32006 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32007 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32008 }
32009 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32010 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32011 }
32012 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32013 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32014 }
32015 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32016 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32017 }
32018 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32019 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32020 }
32021 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32022 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32023 }
32024 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32025 return (void *)((wxObject *) ((wxSizerItem *) x));
32026 }
32027 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32028 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32029 }
32030 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32031 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32032 }
32033 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32034 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32035 }
32036 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32037 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32038 }
32039 static void *_p_wxSizerTo_p_wxObject(void *x) {
32040 return (void *)((wxObject *) ((wxSizer *) x));
32041 }
32042 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32043 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32044 }
32045 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32046 return (void *)((wxObject *) ((wxFileHistory *) x));
32047 }
32048 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32050 }
32051 static void *_p_wxEventTo_p_wxObject(void *x) {
32052 return (void *)((wxObject *) ((wxEvent *) x));
32053 }
32054 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32055 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32056 }
32057 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32058 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32059 }
32060 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32061 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32062 }
32063 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32064 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32065 }
32066 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32067 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32068 }
32069 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32070 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32071 }
32072 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32073 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32074 }
32075 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32076 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32077 }
32078 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32079 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32080 }
32081 static void *_p_wxControlTo_p_wxObject(void *x) {
32082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32083 }
32084 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32085 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32086 }
32087 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32088 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32089 }
32090 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32091 return (void *)((wxObject *) ((wxFSFile *) x));
32092 }
32093 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32094 return (void *)((wxObject *) ((wxClipboard *) x));
32095 }
32096 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32097 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32098 }
32099 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32100 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32101 }
32102 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32103 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32104 }
32105 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32106 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32107 }
32108 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32109 return (void *)((wxObject *) ((wxToolTip *) x));
32110 }
32111 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32112 return (void *)((wxObject *) ((wxMenuItem *) x));
32113 }
32114 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32115 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32116 }
32117 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32118 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32119 }
32120 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32121 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32122 }
32123 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32124 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32125 }
32126 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32127 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32128 }
32129 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32130 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32131 }
32132 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32133 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32134 }
32135 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32136 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32137 }
32138 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32139 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32140 }
32141 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32142 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32143 }
32144 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32145 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32146 }
32147 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32148 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32149 }
32150 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32151 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32152 }
32153 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32154 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32155 }
32156 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32157 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32158 }
32159 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32160 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32161 }
32162 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32163 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32164 }
32165 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32166 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32167 }
32168 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32169 return (void *)((wxObject *) ((wxImageHandler *) x));
32170 }
32171 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32172 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32173 }
32174 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32175 return (void *)((wxObject *) ((wxEvtHandler *) x));
32176 }
32177 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32178 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32179 }
32180 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32181 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32182 }
32183 static void *_p_wxImageTo_p_wxObject(void *x) {
32184 return (void *)((wxObject *) ((wxImage *) x));
32185 }
32186 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32187 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32188 }
32189 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32190 return (void *)((wxObject *) ((wxSystemOptions *) x));
32191 }
32192 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32193 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32194 }
32195 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32196 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32197 }
32198 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32199 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32200 }
32201 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32202 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32203 }
32204 static void *_p_wxWindowTo_p_wxObject(void *x) {
32205 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32206 }
32207 static void *_p_wxMenuTo_p_wxObject(void *x) {
32208 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32209 }
32210 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32211 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32212 }
32213 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32214 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32215 }
32216 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32217 return (void *)((wxObject *) ((wxFileSystem *) x));
32218 }
32219 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32220 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32221 }
32222 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32223 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32224 }
32225 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32226 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32227 }
32228 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32229 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32230 }
32231 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32232 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32233 }
32234 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32235 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32236 }
32237 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32238 return (void *)((wxObject *) ((wxBusyInfo *) x));
32239 }
32240 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32241 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32242 }
32243 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32244 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32245 }
32246 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32247 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32248 }
32249 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32250 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32251 }
32252 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32253 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32254 }
32255 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32256 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32257 }
32258 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32259 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32260 }
32261 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32262 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32263 }
32264 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32265 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32266 }
32267 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32268 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32269 }
32270 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32271 return (void *)((wxLog *) ((wxLogStderr *) x));
32272 }
32273 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32274 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32275 }
32276 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32277 return (void *)((wxLog *) ((wxLogWindow *) x));
32278 }
32279 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32280 return (void *)((wxLog *) ((wxLogChain *) x));
32281 }
32282 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32283 return (void *)((wxLog *) ((wxLogGui *) x));
32284 }
32285 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32286 return (void *)((wxLog *) ((wxPyLog *) x));
32287 }
32288 static void *_p_wxControlTo_p_wxWindow(void *x) {
32289 return (void *)((wxWindow *) ((wxControl *) x));
32290 }
32291 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32292 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32293 }
32294 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32295 return (void *)((wxWindow *) ((wxMenuBar *) x));
32296 }
32297 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32298 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32299 }
32300 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32301 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32302 }
32303 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}};
32304 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}};
32305 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32306 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}};
32307 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}};
32308 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}};
32309 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_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}};
32310 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}};
32311 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}};
32312 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}};
32313 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}};
32314 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}};
32315 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}};
32316 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}};
32317 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}};
32318 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}};
32319 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}};
32320 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}};
32321 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}};
32322 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}};
32323 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}};
32324 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}};
32325 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}};
32326 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}};
32327 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}};
32328 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}};
32329 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}};
32330 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}};
32331 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}};
32332 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}};
32333 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}};
32334 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}};
32335 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}};
32336 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}};
32337 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}};
32338 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}};
32339 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}};
32340 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}};
32341 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}};
32342 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}};
32343 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}};
32344 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}};
32345 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}};
32346 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}};
32347 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}};
32348 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}};
32349 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}};
32350 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}};
32351 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}};
32352 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}};
32353 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}};
32354 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}};
32355 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}};
32356 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}};
32357 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}};
32358 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}};
32359 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}};
32360 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}};
32361 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}};
32362 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}};
32363 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}};
32364 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}};
32365 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}};
32366 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}};
32367 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}};
32368 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}};
32369 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}};
32370 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}};
32371 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}};
32372 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}};
32373 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_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_wxPNGHandler", _p_wxPNGHandlerTo_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_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}};
32374 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}};
32375 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}};
32376 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}};
32377 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}};
32378 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}};
32379 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}};
32380 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}};
32381 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}};
32382 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}};
32383 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}};
32384 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}};
32385 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}};
32386 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}};
32387 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}};
32388 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}};
32389 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}};
32390 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}};
32391 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}};
32392 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}};
32393 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}};
32394 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}};
32395 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}};
32396 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}};
32397 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}};
32398 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}};
32399
32400 static swig_type_info *swig_types_initial[] = {
32401 _swigt__p_wxLogChain,
32402 _swigt__p_wxMutexGuiLocker,
32403 _swigt__p_wxMetafile,
32404 _swigt__p_wxFileHistory,
32405 _swigt__p_wxLog,
32406 _swigt__p_wxMenu,
32407 _swigt__p_wxEvent,
32408 _swigt__p_wxDateTime__TimeZone,
32409 _swigt__p_wxConfigBase,
32410 _swigt__p_wxDisplay,
32411 _swigt__p_wxFileType,
32412 _swigt__p_wxLogGui,
32413 _swigt__p_wxFont,
32414 _swigt__p_wxDataFormat,
32415 _swigt__p_wxTimerEvent,
32416 _swigt__p_wxCaret,
32417 _swigt__ptrdiff_t,
32418 _swigt__std__ptrdiff_t,
32419 _swigt__p_int,
32420 _swigt__p_wxSize,
32421 _swigt__p_wxClipboard,
32422 _swigt__p_wxStopWatch,
32423 _swigt__p_wxClipboardLocker,
32424 _swigt__p_wxIcon,
32425 _swigt__p_wxLogStderr,
32426 _swigt__p_wxLogTextCtrl,
32427 _swigt__p_wxTextCtrl,
32428 _swigt__p_wxBusyCursor,
32429 _swigt__p_wxBitmapDataObject,
32430 _swigt__p_wxTextDataObject,
32431 _swigt__p_wxDataObject,
32432 _swigt__p_wxPyTextDataObject,
32433 _swigt__p_wxPyBitmapDataObject,
32434 _swigt__p_wxFileDataObject,
32435 _swigt__p_wxCustomDataObject,
32436 _swigt__p_wxURLDataObject,
32437 _swigt__p_wxMetafileDataObject,
32438 _swigt__p_wxSound,
32439 _swigt__p_wxTimerRunner,
32440 _swigt__p_wxLogWindow,
32441 _swigt__p_wxTimeSpan,
32442 _swigt__p_wxArrayString,
32443 _swigt__p_wxWindowDisabler,
32444 _swigt__p_form_ops_t,
32445 _swigt__p_wxToolTip,
32446 _swigt__p_wxDataObjectComposite,
32447 _swigt__p_wxFileConfig,
32448 _swigt__p_wxSystemSettings,
32449 _swigt__p_wxVideoMode,
32450 _swigt__p_wxDataObjectSimple,
32451 _swigt__p_wxPyDataObjectSimple,
32452 _swigt__p_wxDuplexMode,
32453 _swigt__p_wxEvtHandler,
32454 _swigt__p_wxRect,
32455 _swigt__p_char,
32456 _swigt__p_wxSingleInstanceChecker,
32457 _swigt__p_wxStandardPaths,
32458 _swigt__p_wxFileTypeInfo,
32459 _swigt__p_wxFrame,
32460 _swigt__p_wxTimer,
32461 _swigt__p_wxPaperSize,
32462 _swigt__p_wxMimeTypesManager,
32463 _swigt__p_wxPyArtProvider,
32464 _swigt__p_wxPyTipProvider,
32465 _swigt__p_wxTipProvider,
32466 _swigt__p_wxJoystick,
32467 _swigt__p_wxSystemOptions,
32468 _swigt__p_wxPoint,
32469 _swigt__p_wxJoystickEvent,
32470 _swigt__p_wxCursor,
32471 _swigt__p_wxObject,
32472 _swigt__p_wxOutputStream,
32473 _swigt__p_wxDateTime,
32474 _swigt__p_wxPyDropSource,
32475 _swigt__p_unsigned_long,
32476 _swigt__p_wxKillError,
32477 _swigt__p_wxWindow,
32478 _swigt__p_wxString,
32479 _swigt__p_wxPyProcess,
32480 _swigt__p_wxBitmap,
32481 _swigt__p_wxConfig,
32482 _swigt__unsigned_int,
32483 _swigt__p_unsigned_int,
32484 _swigt__p_unsigned_char,
32485 _swigt__p_wxChar,
32486 _swigt__p_wxBusyInfo,
32487 _swigt__p_wxPyDropTarget,
32488 _swigt__p_wxPyTextDropTarget,
32489 _swigt__p_wxPyFileDropTarget,
32490 _swigt__p_wxProcessEvent,
32491 _swigt__p_wxPyLog,
32492 _swigt__p_wxLogNull,
32493 _swigt__p_wxColour,
32494 _swigt__p_wxPyTimer,
32495 _swigt__p_wxConfigPathChanger,
32496 _swigt__p_wxDateSpan,
32497 0
32498 };
32499
32500
32501 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32502
32503 static swig_const_info swig_const_table[] = {
32504 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32505 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32506 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32507 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32508 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32509 {0, 0, 0, 0.0, 0, 0}};
32510
32511 #ifdef __cplusplus
32512 }
32513 #endif
32514
32515
32516 #ifdef __cplusplus
32517 extern "C" {
32518 #endif
32519
32520 /* Python-specific SWIG API */
32521 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32522 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32523 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32524
32525 /* -----------------------------------------------------------------------------
32526 * global variable support code.
32527 * ----------------------------------------------------------------------------- */
32528
32529 typedef struct swig_globalvar {
32530 char *name; /* Name of global variable */
32531 PyObject *(*get_attr)(); /* Return the current value */
32532 int (*set_attr)(PyObject *); /* Set the value */
32533 struct swig_globalvar *next;
32534 } swig_globalvar;
32535
32536 typedef struct swig_varlinkobject {
32537 PyObject_HEAD
32538 swig_globalvar *vars;
32539 } swig_varlinkobject;
32540
32541 static PyObject *
32542 swig_varlink_repr(swig_varlinkobject *v) {
32543 v = v;
32544 return PyString_FromString("<Swig global variables>");
32545 }
32546
32547 static int
32548 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32549 swig_globalvar *var;
32550 flags = flags;
32551 fprintf(fp,"Swig global variables { ");
32552 for (var = v->vars; var; var=var->next) {
32553 fprintf(fp,"%s", var->name);
32554 if (var->next) fprintf(fp,", ");
32555 }
32556 fprintf(fp," }\n");
32557 return 0;
32558 }
32559
32560 static PyObject *
32561 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32562 swig_globalvar *var = v->vars;
32563 while (var) {
32564 if (strcmp(var->name,n) == 0) {
32565 return (*var->get_attr)();
32566 }
32567 var = var->next;
32568 }
32569 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32570 return NULL;
32571 }
32572
32573 static int
32574 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32575 swig_globalvar *var = v->vars;
32576 while (var) {
32577 if (strcmp(var->name,n) == 0) {
32578 return (*var->set_attr)(p);
32579 }
32580 var = var->next;
32581 }
32582 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32583 return 1;
32584 }
32585
32586 static PyTypeObject varlinktype = {
32587 PyObject_HEAD_INIT(0)
32588 0, /* Number of items in variable part (ob_size) */
32589 (char *)"swigvarlink", /* Type name (tp_name) */
32590 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32591 0, /* Itemsize (tp_itemsize) */
32592 0, /* Deallocator (tp_dealloc) */
32593 (printfunc) swig_varlink_print, /* Print (tp_print) */
32594 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32595 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32596 0, /* tp_compare */
32597 (reprfunc) swig_varlink_repr, /* tp_repr */
32598 0, /* tp_as_number */
32599 0, /* tp_as_sequence */
32600 0, /* tp_as_mapping */
32601 0, /* tp_hash */
32602 0, /* tp_call */
32603 0, /* tp_str */
32604 0, /* tp_getattro */
32605 0, /* tp_setattro */
32606 0, /* tp_as_buffer */
32607 0, /* tp_flags */
32608 0, /* tp_doc */
32609 #if PY_VERSION_HEX >= 0x02000000
32610 0, /* tp_traverse */
32611 0, /* tp_clear */
32612 #endif
32613 #if PY_VERSION_HEX >= 0x02010000
32614 0, /* tp_richcompare */
32615 0, /* tp_weaklistoffset */
32616 #endif
32617 #if PY_VERSION_HEX >= 0x02020000
32618 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32619 #endif
32620 #if PY_VERSION_HEX >= 0x02030000
32621 0, /* tp_del */
32622 #endif
32623 #ifdef COUNT_ALLOCS
32624 0,0,0,0 /* tp_alloc -> tp_next */
32625 #endif
32626 };
32627
32628 /* Create a variable linking object for use later */
32629 static PyObject *
32630 SWIG_Python_newvarlink(void) {
32631 swig_varlinkobject *result = 0;
32632 result = PyMem_NEW(swig_varlinkobject,1);
32633 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32634 result->ob_type = &varlinktype;
32635 result->vars = 0;
32636 result->ob_refcnt = 0;
32637 Py_XINCREF((PyObject *) result);
32638 return ((PyObject*) result);
32639 }
32640
32641 static void
32642 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32643 swig_varlinkobject *v;
32644 swig_globalvar *gv;
32645 v= (swig_varlinkobject *) p;
32646 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32647 gv->name = (char *) malloc(strlen(name)+1);
32648 strcpy(gv->name,name);
32649 gv->get_attr = get_attr;
32650 gv->set_attr = set_attr;
32651 gv->next = v->vars;
32652 v->vars = gv;
32653 }
32654
32655 /* -----------------------------------------------------------------------------
32656 * constants/methods manipulation
32657 * ----------------------------------------------------------------------------- */
32658
32659 /* Install Constants */
32660 static void
32661 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32662 PyObject *obj = 0;
32663 size_t i;
32664 for (i = 0; constants[i].type; i++) {
32665 switch(constants[i].type) {
32666 case SWIG_PY_INT:
32667 obj = PyInt_FromLong(constants[i].lvalue);
32668 break;
32669 case SWIG_PY_FLOAT:
32670 obj = PyFloat_FromDouble(constants[i].dvalue);
32671 break;
32672 case SWIG_PY_STRING:
32673 if (constants[i].pvalue) {
32674 obj = PyString_FromString((char *) constants[i].pvalue);
32675 } else {
32676 Py_INCREF(Py_None);
32677 obj = Py_None;
32678 }
32679 break;
32680 case SWIG_PY_POINTER:
32681 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32682 break;
32683 case SWIG_PY_BINARY:
32684 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32685 break;
32686 default:
32687 obj = 0;
32688 break;
32689 }
32690 if (obj) {
32691 PyDict_SetItemString(d,constants[i].name,obj);
32692 Py_DECREF(obj);
32693 }
32694 }
32695 }
32696
32697 /* -----------------------------------------------------------------------------*/
32698 /* Fix SwigMethods to carry the callback ptrs when needed */
32699 /* -----------------------------------------------------------------------------*/
32700
32701 static void
32702 SWIG_Python_FixMethods(PyMethodDef *methods,
32703 swig_const_info *const_table,
32704 swig_type_info **types,
32705 swig_type_info **types_initial) {
32706 size_t i;
32707 for (i = 0; methods[i].ml_name; ++i) {
32708 char *c = methods[i].ml_doc;
32709 if (c && (c = strstr(c, "swig_ptr: "))) {
32710 int j;
32711 swig_const_info *ci = 0;
32712 char *name = c + 10;
32713 for (j = 0; const_table[j].type; j++) {
32714 if (strncmp(const_table[j].name, name,
32715 strlen(const_table[j].name)) == 0) {
32716 ci = &(const_table[j]);
32717 break;
32718 }
32719 }
32720 if (ci) {
32721 size_t shift = (ci->ptype) - types;
32722 swig_type_info *ty = types_initial[shift];
32723 size_t ldoc = (c - methods[i].ml_doc);
32724 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32725 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32726 char *buff = ndoc;
32727 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32728 strncpy(buff, methods[i].ml_doc, ldoc);
32729 buff += ldoc;
32730 strncpy(buff, "swig_ptr: ", 10);
32731 buff += 10;
32732 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32733 methods[i].ml_doc = ndoc;
32734 }
32735 }
32736 }
32737 }
32738
32739 /* -----------------------------------------------------------------------------*
32740 * Initialize type list
32741 * -----------------------------------------------------------------------------*/
32742
32743 #if PY_MAJOR_VERSION < 2
32744 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32745 is copied out of Python/modsupport.c in python version 2.3.4 */
32746 static int
32747 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32748 {
32749 PyObject *dict;
32750 if (!PyModule_Check(m)) {
32751 PyErr_SetString(PyExc_TypeError,
32752 "PyModule_AddObject() needs module as first arg");
32753 return -1;
32754 }
32755 if (!o) {
32756 PyErr_SetString(PyExc_TypeError,
32757 "PyModule_AddObject() needs non-NULL value");
32758 return -1;
32759 }
32760
32761 dict = PyModule_GetDict(m);
32762 if (dict == NULL) {
32763 /* Internal error -- modules must have a dict! */
32764 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32765 PyModule_GetName(m));
32766 return -1;
32767 }
32768 if (PyDict_SetItemString(dict, name, o))
32769 return -1;
32770 Py_DECREF(o);
32771 return 0;
32772 }
32773 #endif
32774
32775 static swig_type_info **
32776 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32777 static PyMethodDef swig_empty_runtime_method_table[] = {
32778 {
32779 NULL, NULL, 0, NULL
32780 }
32781 };/* Sentinel */
32782
32783 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32784 swig_empty_runtime_method_table);
32785 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32786 if (pointer && module) {
32787 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32788 }
32789 return type_list_handle;
32790 }
32791
32792 static swig_type_info **
32793 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32794 swig_type_info **type_pointer;
32795
32796 /* first check if module already created */
32797 type_pointer = SWIG_Python_GetTypeListHandle();
32798 if (type_pointer) {
32799 return type_pointer;
32800 } else {
32801 /* create a new module and variable */
32802 return SWIG_Python_SetTypeListHandle(type_list_handle);
32803 }
32804 }
32805
32806 #ifdef __cplusplus
32807 }
32808 #endif
32809
32810 /* -----------------------------------------------------------------------------*
32811 * Partial Init method
32812 * -----------------------------------------------------------------------------*/
32813
32814 #ifdef SWIG_LINK_RUNTIME
32815 #ifdef __cplusplus
32816 extern "C"
32817 #endif
32818 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32819 #endif
32820
32821 #ifdef __cplusplus
32822 extern "C"
32823 #endif
32824 SWIGEXPORT(void) SWIG_init(void) {
32825 static PyObject *SWIG_globals = 0;
32826 static int typeinit = 0;
32827 PyObject *m, *d;
32828 int i;
32829 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32830
32831 /* Fix SwigMethods to carry the callback ptrs when needed */
32832 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32833
32834 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32835 d = PyModule_GetDict(m);
32836
32837 if (!typeinit) {
32838 #ifdef SWIG_LINK_RUNTIME
32839 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32840 #else
32841 # ifndef SWIG_STATIC_RUNTIME
32842 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32843 # endif
32844 #endif
32845 for (i = 0; swig_types_initial[i]; i++) {
32846 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32847 }
32848 typeinit = 1;
32849 }
32850 SWIG_InstallConstants(d,swig_const_table);
32851
32852 {
32853 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32854 }
32855 {
32856 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32857 }
32858 {
32859 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32860 }
32861 {
32862 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32863 }
32864 {
32865 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32866 }
32867 {
32868 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32869 }
32870 {
32871 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32872 }
32873 {
32874 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32875 }
32876 {
32877 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32878 }
32879 {
32880 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32881 }
32882 {
32883 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32884 }
32885 {
32886 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32887 }
32888 {
32889 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32890 }
32891 {
32892 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32893 }
32894 {
32895 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32896 }
32897 {
32898 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32899 }
32900 {
32901 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32902 }
32903 {
32904 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32905 }
32906 {
32907 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32908 }
32909 {
32910 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32911 }
32912 {
32913 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32914 }
32915 {
32916 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33082 }
33083 {
33084 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33085 }
33086 {
33087 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33118 }
33119 {
33120 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33121 }
33122 {
33123 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33124 }
33125 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33126 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33127 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33128 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33129 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33130 {
33131 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33135 }
33136 {
33137 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33138 }
33139 {
33140 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33141 }
33142 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33143
33144 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33145
33146 {
33147 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33178 }
33179 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33180 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33181 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33182 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33183 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33184 {
33185 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33216 }
33217 {
33218 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33219 }
33220 {
33221 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33222 }
33223 {
33224 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33225 }
33226 {
33227 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33228 }
33229 {
33230 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33231 }
33232 {
33233 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33234 }
33235 {
33236 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33237 }
33238 {
33239 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33240 }
33241 {
33242 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33243 }
33244 {
33245 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33246 }
33247 {
33248 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33249 }
33250 {
33251 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33252 }
33253 {
33254 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33270 }
33271 {
33272 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33276 }
33277 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33278 {
33279 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33292 }
33293
33294 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33295
33296 {
33297 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33316 }
33317 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33318 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33319 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33320 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33321 {
33322 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33344 }
33345 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33346 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33347 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33348 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33349 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33350 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33351 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33352 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33353 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33354 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33355 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33356 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33357 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33358 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33359 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33360 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33362 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33363 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33364 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33365 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33366 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33367 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33368 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33369 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33370 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33371 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33372 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33373 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33374 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33375 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33377 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33378 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33379 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33380 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33381 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33382 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33383 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33384 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33385 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33386 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33387 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33388 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33389 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33390
33391 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33392
33393 {
33394 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33419 }
33420 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33421 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33422 {
33423 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33886 }
33887 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33888 {
33889 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33947 }
33948 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33949 {
33950 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33984 }
33985
33986 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33987 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33988 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33989 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33990
33991 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33992 }
33993
wxWidgets (Impactor)