]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Disown the config object when calling wx.ConfigBase.Set
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_p_int swig_types[18]
1361 #define SWIGTYPE_p_wxSize swig_types[19]
1362 #define SWIGTYPE_p_wxClipboard swig_types[20]
1363 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1364 #define SWIGTYPE_p_wxDC swig_types[22]
1365 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1366 #define SWIGTYPE_p_wxIcon swig_types[24]
1367 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1368 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1371 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxSound swig_types[38]
1381 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1382 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1383 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1384 #define SWIGTYPE_p_wxArrayString swig_types[42]
1385 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxToolTip swig_types[45]
1388 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1389 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1390 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1391 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1392 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1395 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1396 #define SWIGTYPE_p_wxRect swig_types[54]
1397 #define SWIGTYPE_p_char swig_types[55]
1398 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1399 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1400 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1401 #define SWIGTYPE_p_wxFrame swig_types[59]
1402 #define SWIGTYPE_p_wxTimer swig_types[60]
1403 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1404 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1405 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1406 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxJoystick swig_types[66]
1409 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1410 #define SWIGTYPE_p_wxPoint swig_types[68]
1411 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1412 #define SWIGTYPE_p_wxCursor swig_types[70]
1413 #define SWIGTYPE_p_wxObject swig_types[71]
1414 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1415 #define SWIGTYPE_p_wxDateTime swig_types[73]
1416 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1417 #define SWIGTYPE_p_unsigned_long swig_types[75]
1418 #define SWIGTYPE_p_wxKillError swig_types[76]
1419 #define SWIGTYPE_p_wxWindow swig_types[77]
1420 #define SWIGTYPE_p_wxString swig_types[78]
1421 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1422 #define SWIGTYPE_p_wxBitmap swig_types[80]
1423 #define SWIGTYPE_p_wxConfig swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_unsigned_char swig_types[84]
1427 #define SWIGTYPE_p_wxChar swig_types[85]
1428 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1429 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1430 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPyLog swig_types[91]
1434 #define SWIGTYPE_p_wxLogNull swig_types[92]
1435 #define SWIGTYPE_p_wxColour swig_types[93]
1436 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1437 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1438 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1439 static swig_type_info *swig_types[98];
1440
1441 /* -------- TYPES TABLE (END) -------- */
1442
1443
1444 /*-----------------------------------------------
1445 @(target):= _misc_.so
1446 ------------------------------------------------*/
1447 #define SWIG_init init_misc_
1448
1449 #define SWIG_name "_misc_"
1450
1451 #include "wx/wxPython/wxPython.h"
1452 #include "wx/wxPython/pyclasses.h"
1453 #include "wx/wxPython/pyistream.h"
1454
1455 static const wxString wxPyEmptyString(wxEmptyString);
1456
1457
1458
1459 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1460 #define SWIG_From_int PyInt_FromLong
1461 /*@@*/
1462
1463
1464 #include <limits.h>
1465
1466
1467 SWIGINTERN int
1468 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1469 const char *errmsg)
1470 {
1471 if (value < min_value) {
1472 if (errmsg) {
1473 PyErr_Format(PyExc_OverflowError,
1474 "value %ld is less than '%s' minimum %ld",
1475 value, errmsg, min_value);
1476 }
1477 return 0;
1478 } else if (value > max_value) {
1479 if (errmsg) {
1480 PyErr_Format(PyExc_OverflowError,
1481 "value %ld is greater than '%s' maximum %ld",
1482 value, errmsg, max_value);
1483 }
1484 return 0;
1485 }
1486 return 1;
1487 }
1488
1489
1490 SWIGINTERN int
1491 SWIG_AsVal_long(PyObject* obj, long* val)
1492 {
1493 if (PyNumber_Check(obj)) {
1494 if (val) *val = PyInt_AsLong(obj);
1495 return 1;
1496 }
1497 else {
1498 SWIG_type_error("number", obj);
1499 }
1500 return 0;
1501 }
1502
1503
1504 #if INT_MAX != LONG_MAX
1505 SWIGINTERN int
1506 SWIG_AsVal_int(PyObject *obj, int *val)
1507 {
1508 const char* errmsg = val ? "int" : (char*)0;
1509 long v;
1510 if (SWIG_AsVal_long(obj, &v)) {
1511 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1512 if (val) *val = (int)(v);
1513 return 1;
1514 } else {
1515 return 0;
1516 }
1517 } else {
1518 PyErr_Clear();
1519 }
1520 if (val) {
1521 SWIG_type_error(errmsg, obj);
1522 }
1523 return 0;
1524 }
1525 #else
1526 SWIGINTERNSHORT int
1527 SWIG_AsVal_int(PyObject *obj, int *val)
1528 {
1529 return SWIG_AsVal_long(obj,(long*)val);
1530 }
1531 #endif
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_As_int(PyObject* obj)
1536 {
1537 int v;
1538 if (!SWIG_AsVal_int(obj, &v)) {
1539 /*
1540 this is needed to make valgrind/purify happier.
1541 */
1542 memset((void*)&v, 0, sizeof(int));
1543 }
1544 return v;
1545 }
1546
1547
1548 SWIGINTERNSHORT int
1549 SWIG_Check_int(PyObject* obj)
1550 {
1551 return SWIG_AsVal_int(obj, (int*)0);
1552 }
1553
1554 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1555
1556 #include <wx/stockitem.h>
1557
1558 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1559 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1560 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1561
1562 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1563 #define SWIG_From_long PyInt_FromLong
1564 /*@@*/
1565
1566
1567 SWIGINTERNSHORT long
1568 SWIG_As_long(PyObject* obj)
1569 {
1570 long v;
1571 if (!SWIG_AsVal_long(obj, &v)) {
1572 /*
1573 this is needed to make valgrind/purify happier.
1574 */
1575 memset((void*)&v, 0, sizeof(long));
1576 }
1577 return v;
1578 }
1579
1580
1581 SWIGINTERNSHORT int
1582 SWIG_Check_long(PyObject* obj)
1583 {
1584 return SWIG_AsVal_long(obj, (long*)0);
1585 }
1586
1587
1588 SWIGINTERN int
1589 SWIG_AsVal_bool(PyObject *obj, bool *val)
1590 {
1591 if (obj == Py_True) {
1592 if (val) *val = true;
1593 return 1;
1594 }
1595 if (obj == Py_False) {
1596 if (val) *val = false;
1597 return 1;
1598 }
1599 int res = 0;
1600 if (SWIG_AsVal_int(obj, &res)) {
1601 if (val) *val = res ? true : false;
1602 return 1;
1603 } else {
1604 PyErr_Clear();
1605 }
1606 if (val) {
1607 SWIG_type_error("bool", obj);
1608 }
1609 return 0;
1610 }
1611
1612
1613 SWIGINTERNSHORT bool
1614 SWIG_As_bool(PyObject* obj)
1615 {
1616 bool v;
1617 if (!SWIG_AsVal_bool(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(bool));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_bool(PyObject* obj)
1629 {
1630 return SWIG_AsVal_bool(obj, (bool*)0);
1631 }
1632
1633
1634 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1635 PyObject* o2;
1636 PyObject* o3;
1637
1638 if (!target) {
1639 target = o;
1640 } else if (target == Py_None) {
1641 Py_DECREF(Py_None);
1642 target = o;
1643 } else {
1644 if (!PyTuple_Check(target)) {
1645 o2 = target;
1646 target = PyTuple_New(1);
1647 PyTuple_SetItem(target, 0, o2);
1648 }
1649 o3 = PyTuple_New(1);
1650 PyTuple_SetItem(o3, 0, o);
1651
1652 o2 = target;
1653 target = PySequence_Concat(o2, o3);
1654 Py_DECREF(o2);
1655 Py_DECREF(o3);
1656 }
1657 return target;
1658 }
1659
1660
1661
1662 SWIGINTERN int
1663 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1664 {
1665 long v = 0;
1666 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1667 SWIG_type_error("unsigned number", obj);
1668 }
1669 else if (val)
1670 *val = (unsigned long)v;
1671 return 1;
1672 }
1673
1674
1675 SWIGINTERNSHORT unsigned long
1676 SWIG_As_unsigned_SS_long(PyObject* obj)
1677 {
1678 unsigned long v;
1679 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1680 /*
1681 this is needed to make valgrind/purify happier.
1682 */
1683 memset((void*)&v, 0, sizeof(unsigned long));
1684 }
1685 return v;
1686 }
1687
1688
1689 SWIGINTERNSHORT int
1690 SWIG_Check_unsigned_SS_long(PyObject* obj)
1691 {
1692 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1693 }
1694
1695
1696 SWIGINTERNSHORT PyObject*
1697 SWIG_From_unsigned_SS_long(unsigned long value)
1698 {
1699 return (value > LONG_MAX) ?
1700 PyLong_FromUnsignedLong(value)
1701 : PyInt_FromLong((long)(value));
1702 }
1703
1704
1705 bool wxThread_IsMain() {
1706 #ifdef WXP_WITH_THREAD
1707 return wxThread::IsMain();
1708 #else
1709 return true;
1710 #endif
1711 }
1712
1713 static void wxCaret_Destroy(wxCaret *self){
1714 delete self;
1715 }
1716
1717 #include <wx/snglinst.h>
1718
1719
1720 #ifdef __WXMSW__
1721 #include <wx/msw/private.h>
1722 #include <wx/dynload.h>
1723 #endif
1724
1725
1726
1727 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1728 #if 0
1729 , int method
1730 #endif
1731 )
1732 {
1733 #ifdef __WXMSW__
1734 #if 0
1735 switch (method)
1736 {
1737 case 1:
1738 // This one only partially works. Appears to be an undocumented
1739 // "standard" convention that not all widgets adhear to. For
1740 // example, for some widgets backgrounds or non-client areas may
1741 // not be painted.
1742 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1743 break;
1744
1745 case 2:
1746 #endif
1747 // This one works much better, nearly all widgets and their
1748 // children are captured correctly[**]. Prior to the big
1749 // background erase changes that Vadim did in 2004-2005 this
1750 // method failed badly on XP with Themes activated, most native
1751 // widgets draw only partially, if at all. Without themes it
1752 // worked just like on Win2k. After those changes this method
1753 // works very well.
1754 //
1755 // ** For example the radio buttons in a wxRadioBox are not its
1756 // children by default, but you can capture it via the panel
1757 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1758 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1759 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1760 PRF_ERASEBKGND | PRF_OWNED );
1761 return true;
1762 #if 0
1763 break;
1764
1765 case 3:
1766 // This one is only defined in the latest SDK and is only
1767 // available on XP. MSDN says it is similar to sending WM_PRINT
1768 // so I expect that it will work similar to the above. Since it
1769 // is avaialble only on XP, it can't be compiled like this and
1770 // will have to be loaded dynamically.
1771 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1772
1773 // fall through
1774
1775 case 4:
1776 // Use PrintWindow if available, or fallback to WM_PRINT
1777 // otherwise. Unfortunately using PrintWindow is even worse than
1778 // WM_PRINT. For most native widgets nothing is drawn to the dc
1779 // at all, with or without Themes.
1780 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1781 static bool s_triedToLoad = false;
1782 static PrintWindow_t pfnPrintWindow = NULL;
1783 if ( !s_triedToLoad )
1784 {
1785
1786 s_triedToLoad = true;
1787 wxDynamicLibrary dllUser32(_T("user32.dll"));
1788 if ( dllUser32.IsLoaded() )
1789 {
1790 wxLogNull nolog; // Don't report errors here
1791 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1792 }
1793 }
1794 if (pfnPrintWindow)
1795 {
1796 //printf("Using PrintWindow\n");
1797 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1798 }
1799 else
1800 {
1801 //printf("Using WM_PRINT\n");
1802 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1803 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1804 PRF_ERASEBKGND | PRF_OWNED );
1805 }
1806 }
1807 #endif // 0
1808 #else
1809 return false;
1810 #endif // __WXMSW__
1811 }
1812
1813
1814
1815 #include <wx/tipdlg.h>
1816
1817
1818 class wxPyTipProvider : public wxTipProvider {
1819 public:
1820 wxPyTipProvider(size_t currentTip)
1821 : wxTipProvider(currentTip) {}
1822
1823 DEC_PYCALLBACK_STRING__pure(GetTip);
1824 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1825 PYPRIVATE;
1826 };
1827
1828 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1829 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1830
1831
1832 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1833
1834 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1835
1836 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1837 : wxTimer(owner, id)
1838 {
1839 if (owner == NULL) SetOwner(this);
1840 }
1841
1842
1843 void wxPyTimer::Notify() {
1844 bool found;
1845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1846 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1847 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1848 wxPyEndBlockThreads(blocked);
1849 if (! found)
1850 wxTimer::Notify();
1851 }
1852 void wxPyTimer::base_Notify() {
1853 wxTimer::Notify();
1854 }
1855
1856
1857
1858 SWIGINTERN PyObject *
1859 SWIG_FromCharPtr(const char* cptr)
1860 {
1861 if (cptr) {
1862 size_t size = strlen(cptr);
1863 if (size > INT_MAX) {
1864 return SWIG_NewPointerObj((char*)(cptr),
1865 SWIG_TypeQuery("char *"), 0);
1866 } else {
1867 if (size != 0) {
1868 return PyString_FromStringAndSize(cptr, size);
1869 } else {
1870 return PyString_FromString(cptr);
1871 }
1872 }
1873 }
1874 Py_INCREF(Py_None);
1875 return Py_None;
1876 }
1877
1878
1879 SWIGINTERNSHORT int
1880 SWIG_CheckUnsignedLongInRange(unsigned long value,
1881 unsigned long max_value,
1882 const char *errmsg)
1883 {
1884 if (value > max_value) {
1885 if (errmsg) {
1886 PyErr_Format(PyExc_OverflowError,
1887 "value %lu is greater than '%s' minimum %lu",
1888 value, errmsg, max_value);
1889 }
1890 return 0;
1891 }
1892 return 1;
1893 }
1894
1895
1896 #if UINT_MAX != ULONG_MAX
1897 SWIGINTERN int
1898 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1899 {
1900 const char* errmsg = val ? "unsigned int" : (char*)0;
1901 unsigned long v;
1902 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1903 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1904 if (val) *val = (unsigned int)(v);
1905 return 1;
1906 }
1907 } else {
1908 PyErr_Clear();
1909 }
1910 if (val) {
1911 SWIG_type_error(errmsg, obj);
1912 }
1913 return 0;
1914 }
1915 #else
1916 SWIGINTERNSHORT unsigned int
1917 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1918 {
1919 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1920 }
1921 #endif
1922
1923
1924 SWIGINTERNSHORT unsigned int
1925 SWIG_As_unsigned_SS_int(PyObject* obj)
1926 {
1927 unsigned int v;
1928 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1929 /*
1930 this is needed to make valgrind/purify happier.
1931 */
1932 memset((void*)&v, 0, sizeof(unsigned int));
1933 }
1934 return v;
1935 }
1936
1937
1938 SWIGINTERNSHORT int
1939 SWIG_Check_unsigned_SS_int(PyObject* obj)
1940 {
1941 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1942 }
1943
1944 static wxString Log_TimeStamp(){
1945 wxString msg;
1946 wxLog::TimeStamp(&msg);
1947 return msg;
1948 }
1949 static void wxLog_Destroy(wxLog *self){ delete self; }
1950 // Make somce wrappers that double any % signs so they are 'escaped'
1951 void wxPyLogFatalError(const wxString& msg)
1952 {
1953 wxString m(msg);
1954 m.Replace(wxT("%"), wxT("%%"));
1955 wxLogFatalError(m);
1956 }
1957
1958 void wxPyLogError(const wxString& msg)
1959 {
1960 wxString m(msg);
1961 m.Replace(wxT("%"), wxT("%%"));
1962 wxLogError(m);
1963 }
1964
1965 void wxPyLogWarning(const wxString& msg)
1966 {
1967 wxString m(msg);
1968 m.Replace(wxT("%"), wxT("%%"));
1969 wxLogWarning(m);
1970 }
1971
1972 void wxPyLogMessage(const wxString& msg)
1973 {
1974 wxString m(msg);
1975 m.Replace(wxT("%"), wxT("%%"));
1976 wxLogMessage(m);
1977 }
1978
1979 void wxPyLogInfo(const wxString& msg)
1980 {
1981 wxString m(msg);
1982 m.Replace(wxT("%"), wxT("%%"));
1983 wxLogInfo(m);
1984 }
1985
1986 void wxPyLogDebug(const wxString& msg)
1987 {
1988 wxString m(msg);
1989 m.Replace(wxT("%"), wxT("%%"));
1990 wxLogDebug(m);
1991 }
1992
1993 void wxPyLogVerbose(const wxString& msg)
1994 {
1995 wxString m(msg);
1996 m.Replace(wxT("%"), wxT("%%"));
1997 wxLogVerbose(m);
1998 }
1999
2000 void wxPyLogStatus(const wxString& msg)
2001 {
2002 wxString m(msg);
2003 m.Replace(wxT("%"), wxT("%%"));
2004 wxLogStatus(m);
2005 }
2006
2007 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2008 {
2009 wxString m(msg);
2010 m.Replace(wxT("%"), wxT("%%"));
2011 wxLogStatus(pFrame, m);
2012 }
2013
2014 void wxPyLogSysError(const wxString& msg)
2015 {
2016 wxString m(msg);
2017 m.Replace(wxT("%"), wxT("%%"));
2018 wxLogSysError(m);
2019 }
2020
2021 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2022 {
2023 wxString m(msg);
2024 m.Replace(wxT("%"), wxT("%%"));
2025 wxLogGeneric(level, m);
2026 }
2027
2028 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2029 {
2030 wxString m(msg);
2031 m.Replace(wxT("%"), wxT("%%"));
2032 wxLogTrace(mask, m);
2033 }
2034
2035 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2036 {
2037 wxString m(msg);
2038 m.Replace(wxT("%"), wxT("%%"));
2039 wxLogTrace(mask, m);
2040 }
2041
2042
2043
2044 // A wxLog class that can be derived from in wxPython
2045 class wxPyLog : public wxLog {
2046 public:
2047 wxPyLog() : wxLog() {}
2048
2049 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2050 bool found;
2051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2052 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2053 PyObject* s = wx2PyString(szString);
2054 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2055 Py_DECREF(s);
2056 }
2057 wxPyEndBlockThreads(blocked);
2058 if (! found)
2059 wxLog::DoLog(level, szString, t);
2060 }
2061
2062 virtual void DoLogString(const wxChar *szString, time_t t) {
2063 bool found;
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2066 PyObject* s = wx2PyString(szString);
2067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2068 Py_DECREF(s);
2069 }
2070 wxPyEndBlockThreads(blocked);
2071 if (! found)
2072 wxLog::DoLogString(szString, t);
2073 }
2074
2075 PYPRIVATE;
2076 };
2077
2078
2079
2080
2081 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2082
2083
2084 #include <wx/joystick.h>
2085
2086
2087 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2088 // A C++ stub class for wxJoystick for platforms that don't have it.
2089 class wxJoystick : public wxObject {
2090 public:
2091 wxJoystick(int joystick = wxJOYSTICK1) {
2092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2093 PyErr_SetString(PyExc_NotImplementedError,
2094 "wxJoystick is not available on this platform.");
2095 wxPyEndBlockThreads(blocked);
2096 }
2097 wxPoint GetPosition() { return wxPoint(-1,-1); }
2098 int GetZPosition() { return -1; }
2099 int GetButtonState() { return -1; }
2100 int GetPOVPosition() { return -1; }
2101 int GetPOVCTSPosition() { return -1; }
2102 int GetRudderPosition() { return -1; }
2103 int GetUPosition() { return -1; }
2104 int GetVPosition() { return -1; }
2105 int GetMovementThreshold() { return -1; }
2106 void SetMovementThreshold(int threshold) {}
2107
2108 bool IsOk(void) { return false; }
2109 int GetNumberJoysticks() { return -1; }
2110 int GetManufacturerId() { return -1; }
2111 int GetProductId() { return -1; }
2112 wxString GetProductName() { return wxEmptyString; }
2113 int GetXMin() { return -1; }
2114 int GetYMin() { return -1; }
2115 int GetZMin() { return -1; }
2116 int GetXMax() { return -1; }
2117 int GetYMax() { return -1; }
2118 int GetZMax() { return -1; }
2119 int GetNumberButtons() { return -1; }
2120 int GetNumberAxes() { return -1; }
2121 int GetMaxButtons() { return -1; }
2122 int GetMaxAxes() { return -1; }
2123 int GetPollingMin() { return -1; }
2124 int GetPollingMax() { return -1; }
2125 int GetRudderMin() { return -1; }
2126 int GetRudderMax() { return -1; }
2127 int GetUMin() { return -1; }
2128 int GetUMax() { return -1; }
2129 int GetVMin() { return -1; }
2130 int GetVMax() { return -1; }
2131
2132 bool HasRudder() { return false; }
2133 bool HasZ() { return false; }
2134 bool HasU() { return false; }
2135 bool HasV() { return false; }
2136 bool HasPOV() { return false; }
2137 bool HasPOV4Dir() { return false; }
2138 bool HasPOVCTS() { return false; }
2139
2140 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2141 bool ReleaseCapture() { return false; }
2142 };
2143 #endif
2144
2145
2146 #include <wx/sound.h>
2147
2148
2149 #if !wxUSE_SOUND
2150 // A C++ stub class for wxWave for platforms that don't have it.
2151 class wxSound : public wxObject
2152 {
2153 public:
2154 wxSound() {
2155 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2156 PyErr_SetString(PyExc_NotImplementedError,
2157 "wxSound is not available on this platform.");
2158 wxPyEndBlockThreads(blocked);
2159 }
2160 wxSound(const wxString&/*, bool*/) {
2161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2162 PyErr_SetString(PyExc_NotImplementedError,
2163 "wxSound is not available on this platform.");
2164 wxPyEndBlockThreads(blocked);
2165 }
2166 wxSound(int, const wxByte*) {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172
2173 ~wxSound() {};
2174
2175 bool Create(const wxString&/*, bool*/) { return false; }
2176 bool Create(int, const wxByte*) { return false; };
2177 bool IsOk() { return false; };
2178 bool Play(unsigned) const { return false; }
2179 static bool Play(const wxString&, unsigned) { return false; }
2180 static void Stop() {}
2181 };
2182
2183 #endif
2184
2185 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2186 if (fileName.Length() == 0)
2187 return new wxSound;
2188 else
2189 return new wxSound(fileName);
2190 }
2191 static wxSound *new_wxSound(PyObject *data){
2192 unsigned char* buffer; int size;
2193 wxSound *sound = NULL;
2194
2195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2196 if (!PyArg_Parse(data, "t#", &buffer, &size))
2197 goto done;
2198 sound = new wxSound(size, buffer);
2199 done:
2200 wxPyEndBlockThreads(blocked);
2201 return sound;
2202 }
2203 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2204 #ifndef __WXMAC__
2205 unsigned char* buffer;
2206 int size;
2207 bool rv = false;
2208
2209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2210 if (!PyArg_Parse(data, "t#", &buffer, &size))
2211 goto done;
2212 rv = self->Create(size, buffer);
2213 done:
2214 wxPyEndBlockThreads(blocked);
2215 return rv;
2216 #else
2217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2218 PyErr_SetString(PyExc_NotImplementedError,
2219 "Create from data is not available on this platform.");
2220 wxPyEndBlockThreads(blocked);
2221 return false;
2222 #endif
2223 }
2224
2225 #include <wx/mimetype.h>
2226
2227 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2228 wxString str;
2229 if (self->GetMimeType(&str))
2230 return wx2PyString(str);
2231 else
2232 RETURN_NONE();
2233 }
2234 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2235 wxArrayString arr;
2236 if (self->GetMimeTypes(arr))
2237 return wxArrayString2PyList_helper(arr);
2238 else
2239 RETURN_NONE();
2240 }
2241 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2242 wxArrayString arr;
2243 if (self->GetExtensions(arr))
2244 return wxArrayString2PyList_helper(arr);
2245 else
2246 RETURN_NONE();
2247 }
2248 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2249 wxIconLocation loc;
2250 if (self->GetIcon(&loc))
2251 return new wxIcon(loc);
2252 else
2253 return NULL;
2254 }
2255 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2256 wxIconLocation loc;
2257 if (self->GetIcon(&loc)) {
2258 wxString iconFile = loc.GetFileName();
2259 int iconIndex = -1;
2260
2261
2262
2263 // Make a tuple and put the values in it
2264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2265 PyObject* tuple = PyTuple_New(3);
2266 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2267 wxT("wxIcon"), true));
2268 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2269 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2270 wxPyEndBlockThreads(blocked);
2271 return tuple;
2272 }
2273 else
2274 RETURN_NONE();
2275 }
2276 static PyObject *wxFileType_GetDescription(wxFileType *self){
2277 wxString str;
2278 if (self->GetDescription(&str))
2279 return wx2PyString(str);
2280 else
2281 RETURN_NONE();
2282 }
2283 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2284 wxString str;
2285 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2286 return wx2PyString(str);
2287 else
2288 RETURN_NONE();
2289 }
2290 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2291 wxString str;
2292 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2293 return wx2PyString(str);
2294 else
2295 RETURN_NONE();
2296 }
2297 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2298 wxArrayString verbs;
2299 wxArrayString commands;
2300 if (self->GetAllCommands(&verbs, &commands,
2301 wxFileType::MessageParameters(filename, mimetype))) {
2302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2303 PyObject* tuple = PyTuple_New(2);
2304 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2305 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2306 wxPyEndBlockThreads(blocked);
2307 return tuple;
2308 }
2309 else
2310 RETURN_NONE();
2311 }
2312 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2313 return wxFileType::ExpandCommand(command,
2314 wxFileType::MessageParameters(filename, mimetype));
2315 }
2316 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2317 wxArrayString arr;
2318 self->EnumAllFileTypes(arr);
2319 return wxArrayString2PyList_helper(arr);
2320 }
2321
2322 #include <wx/artprov.h>
2323
2324 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2325 static const wxString wxPyART_MENU(wxART_MENU);
2326 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2327 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2328 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2329 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2330 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2331 static const wxString wxPyART_OTHER(wxART_OTHER);
2332 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2333 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2334 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2335 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2336 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2337 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2338 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2339 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2340 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2341 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2342 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2343 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2344 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2345 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2346 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2347 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2348 static const wxString wxPyART_PRINT(wxART_PRINT);
2349 static const wxString wxPyART_HELP(wxART_HELP);
2350 static const wxString wxPyART_TIP(wxART_TIP);
2351 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2352 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2353 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2354 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2355 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2356 static const wxString wxPyART_CDROM(wxART_CDROM);
2357 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2358 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2359 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2360 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2361 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2362 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2363 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2364 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2365 static const wxString wxPyART_ERROR(wxART_ERROR);
2366 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2367 static const wxString wxPyART_WARNING(wxART_WARNING);
2368 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2369 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2370 static const wxString wxPyART_COPY(wxART_COPY);
2371 static const wxString wxPyART_CUT(wxART_CUT);
2372 static const wxString wxPyART_PASTE(wxART_PASTE);
2373 static const wxString wxPyART_DELETE(wxART_DELETE);
2374 static const wxString wxPyART_UNDO(wxART_UNDO);
2375 static const wxString wxPyART_REDO(wxART_REDO);
2376 static const wxString wxPyART_QUIT(wxART_QUIT);
2377 static const wxString wxPyART_FIND(wxART_FIND);
2378 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2379 // Python aware wxArtProvider
2380 class wxPyArtProvider : public wxArtProvider {
2381 public:
2382
2383 virtual wxBitmap CreateBitmap(const wxArtID& id,
2384 const wxArtClient& client,
2385 const wxSize& size) {
2386 wxBitmap rval = wxNullBitmap;
2387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2388 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2389 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2390 PyObject* ro;
2391 wxBitmap* ptr;
2392 PyObject* s1, *s2;
2393 s1 = wx2PyString(id);
2394 s2 = wx2PyString(client);
2395 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2396 Py_DECREF(so);
2397 Py_DECREF(s1);
2398 Py_DECREF(s2);
2399 if (ro) {
2400 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2401 rval = *ptr;
2402 Py_DECREF(ro);
2403 }
2404 }
2405 wxPyEndBlockThreads(blocked);
2406 return rval;
2407 }
2408
2409 PYPRIVATE;
2410 };
2411
2412 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2413
2414
2415
2416 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2417 PyObject* ret = PyTuple_New(3);
2418 if (ret) {
2419 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2420 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2421 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2422 }
2423 return ret;
2424 }
2425
2426 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2427 bool cont;
2428 long index = 0;
2429 wxString value;
2430
2431 cont = self->GetFirstGroup(value, index);
2432 return __EnumerationHelper(cont, value, index);
2433 }
2434 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2435 bool cont;
2436 wxString value;
2437
2438 cont = self->GetNextGroup(value, index);
2439 return __EnumerationHelper(cont, value, index);
2440 }
2441 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2442 bool cont;
2443 long index = 0;
2444 wxString value;
2445
2446 cont = self->GetFirstEntry(value, index);
2447 return __EnumerationHelper(cont, value, index);
2448 }
2449 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2450 bool cont;
2451 wxString value;
2452
2453 cont = self->GetNextEntry(value, index);
2454 return __EnumerationHelper(cont, value, index);
2455 }
2456 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2457 long rv;
2458 self->Read(key, &rv, defaultVal);
2459 return rv;
2460 }
2461
2462 SWIGINTERN int
2463 SWIG_AsVal_double(PyObject *obj, double* val)
2464 {
2465 if (PyNumber_Check(obj)) {
2466 if (val) *val = PyFloat_AsDouble(obj);
2467 return 1;
2468 }
2469 else {
2470 SWIG_type_error("number", obj);
2471 }
2472 return 0;
2473 }
2474
2475
2476 SWIGINTERNSHORT double
2477 SWIG_As_double(PyObject* obj)
2478 {
2479 double v;
2480 if (!SWIG_AsVal_double(obj, &v)) {
2481 /*
2482 this is needed to make valgrind/purify happier.
2483 */
2484 memset((void*)&v, 0, sizeof(double));
2485 }
2486 return v;
2487 }
2488
2489
2490 SWIGINTERNSHORT int
2491 SWIG_Check_double(PyObject* obj)
2492 {
2493 return SWIG_AsVal_double(obj, (double*)0);
2494 }
2495
2496 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2497 double rv;
2498 self->Read(key, &rv, defaultVal);
2499 return rv;
2500 }
2501
2502 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2503 #define SWIG_From_double PyFloat_FromDouble
2504 /*@@*/
2505
2506 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2507 bool rv;
2508 self->Read(key, &rv, defaultVal);
2509 return rv;
2510 }
2511
2512 #include <wx/datetime.h>
2513
2514 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2515 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2516
2517 #define LOCAL_TZ wxDateTime::Local
2518
2519 static PyObject *DateTime_GetAmPmStrings(){
2520 wxString am;
2521 wxString pm;
2522 wxDateTime::GetAmPmStrings(&am, &pm);
2523 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2524 PyObject* tup = PyTuple_New(2);
2525 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2526 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2527 wxPyEndBlockThreads(blocked);
2528 return tup;
2529 }
2530
2531 #if UINT_MAX < LONG_MAX
2532 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2533 #define SWIG_From_unsigned_SS_int SWIG_From_long
2534 /*@@*/
2535 #else
2536 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2537 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2538 /*@@*/
2539 #endif
2540
2541 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2542 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2543 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2545 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2546 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2547 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2548 return (*self < *other);
2549 }
2550 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2551 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2552 return (*self <= *other);
2553 }
2554 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2555 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2556 return (*self > *other);
2557 }
2558 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2559 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2560 return (*self >= *other);
2561 }
2562 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2563 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2564 return (*self == *other);
2565 }
2566 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2567 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2568 return (*self != *other);
2569 }
2570 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2571 const wxChar* rv;
2572 const wxChar* _date = date;
2573 rv = self->ParseRfc822Date(_date);
2574 if (rv == NULL) return -1;
2575 return rv - _date;
2576 }
2577 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2578 const wxChar* rv;
2579 const wxChar* _date = date;
2580 rv = self->ParseFormat(_date, format, dateDef);
2581 if (rv == NULL) return -1;
2582 return rv - _date;
2583 }
2584 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2585 const wxChar* rv;
2586 const wxChar* _datetime = datetime;
2587 rv = self->ParseDateTime(_datetime);
2588 if (rv == NULL) return -1;
2589 return rv - _datetime;
2590 }
2591 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2592 const wxChar* rv;
2593 const wxChar* _date = date;
2594 rv = self->ParseDate(_date);
2595 if (rv == NULL) return -1;
2596 return rv - _date;
2597 }
2598 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2599 const wxChar* rv;
2600 const wxChar* _time = time;
2601 rv = self->ParseTime(_time);
2602 if (rv == NULL) return -1;
2603 return rv - _time;
2604 }
2605 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2606 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2607 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2608 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2609 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2610 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2611 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2612 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2613 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2614 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2615 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2616 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2617 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2618 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2619 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2620 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2621
2622 #include <wx/dataobj.h>
2623
2624 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2625 size_t count = self->GetFormatCount(dir);
2626 wxDataFormat* formats = new wxDataFormat[count];
2627 self->GetAllFormats(formats, dir);
2628
2629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2630 PyObject* list = PyList_New(count);
2631 for (size_t i=0; i<count; i++) {
2632 wxDataFormat* format = new wxDataFormat(formats[i]);
2633 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2634 PyList_Append(list, obj);
2635 Py_DECREF(obj);
2636 }
2637 wxPyEndBlockThreads(blocked);
2638 delete [] formats;
2639 return list;
2640 }
2641 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2642 PyObject* rval = NULL;
2643 size_t size = self->GetDataSize(format);
2644 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2645 if (size) {
2646 char* buf = new char[size];
2647 if (self->GetDataHere(format, buf))
2648 rval = PyString_FromStringAndSize(buf, size);
2649 delete [] buf;
2650 }
2651 if (! rval) {
2652 rval = Py_None;
2653 Py_INCREF(rval);
2654 }
2655 wxPyEndBlockThreads(blocked);
2656 return rval;
2657 }
2658 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2659 bool rval;
2660 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2661 if (PyString_Check(data)) {
2662 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2663 }
2664 else {
2665 // raise a TypeError if not a string
2666 PyErr_SetString(PyExc_TypeError, "String expected.");
2667 rval = false;
2668 }
2669 wxPyEndBlockThreads(blocked);
2670 return rval;
2671 }
2672 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2673 PyObject* rval = NULL;
2674 size_t size = self->GetDataSize();
2675 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2676 if (size) {
2677 char* buf = new char[size];
2678 if (self->GetDataHere(buf))
2679 rval = PyString_FromStringAndSize(buf, size);
2680 delete [] buf;
2681 }
2682 if (! rval) {
2683 rval = Py_None;
2684 Py_INCREF(rval);
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 return rval;
2688 }
2689 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2690 bool rval;
2691 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2692 if (PyString_Check(data)) {
2693 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2694 }
2695 else {
2696 // raise a TypeError if not a string
2697 PyErr_SetString(PyExc_TypeError, "String expected.");
2698 rval = false;
2699 }
2700 wxPyEndBlockThreads(blocked);
2701 return rval;
2702 }
2703 // Create a new class for wxPython to use
2704 class wxPyDataObjectSimple : public wxDataObjectSimple {
2705 public:
2706 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2707 : wxDataObjectSimple(format) {}
2708
2709 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2710 bool GetDataHere(void *buf) const;
2711 bool SetData(size_t len, const void *buf) const;
2712 PYPRIVATE;
2713 };
2714
2715 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2716
2717 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2718 // We need to get the data for this object and write it to buf. I think
2719 // the best way to do this for wxPython is to have the Python method
2720 // return either a string or None and then act appropriately with the
2721 // C++ version.
2722
2723 bool rval = false;
2724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2725 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2726 PyObject* ro;
2727 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2728 if (ro) {
2729 rval = (ro != Py_None && PyString_Check(ro));
2730 if (rval)
2731 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2732 Py_DECREF(ro);
2733 }
2734 }
2735 wxPyEndBlockThreads(blocked);
2736 return rval;
2737 }
2738
2739 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2740 // For this one we simply need to make a string from buf and len
2741 // and send it to the Python method.
2742 bool rval = false;
2743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2744 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2745 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2746 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2747 Py_DECREF(data);
2748 }
2749 wxPyEndBlockThreads(blocked);
2750 return rval;
2751 }
2752
2753 // Create a new class for wxPython to use
2754 class wxPyTextDataObject : public wxTextDataObject {
2755 public:
2756 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2757 : wxTextDataObject(text) {}
2758
2759 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2760 DEC_PYCALLBACK_STRING__const(GetText);
2761 DEC_PYCALLBACK__STRING(SetText);
2762 PYPRIVATE;
2763 };
2764
2765 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2766 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2767 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2768
2769
2770 // Create a new class for wxPython to use
2771 class wxPyBitmapDataObject : public wxBitmapDataObject {
2772 public:
2773 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2774 : wxBitmapDataObject(bitmap) {}
2775
2776 wxBitmap GetBitmap() const;
2777 void SetBitmap(const wxBitmap& bitmap);
2778 PYPRIVATE;
2779 };
2780
2781 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2782 wxBitmap* rval = &wxNullBitmap;
2783 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2784 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2785 PyObject* ro;
2786 wxBitmap* ptr;
2787 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2788 if (ro) {
2789 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2790 rval = ptr;
2791 Py_DECREF(ro);
2792 }
2793 }
2794 wxPyEndBlockThreads(blocked);
2795 return *rval;
2796 }
2797
2798 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2799 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2800 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2801 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2802 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2803 Py_DECREF(bo);
2804 }
2805 wxPyEndBlockThreads(blocked);
2806 }
2807
2808 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2809 return new wxCustomDataObject(wxDataFormat(formatName));
2810 }
2811 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2812 bool rval;
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 if (PyString_Check(data)) {
2815 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2816 }
2817 else {
2818 // raise a TypeError if not a string
2819 PyErr_SetString(PyExc_TypeError, "String expected.");
2820 rval = false;
2821 }
2822 wxPyEndBlockThreads(blocked);
2823 return rval;
2824 }
2825 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2826 PyObject* obj;
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2828 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2829 wxPyEndBlockThreads(blocked);
2830 return obj;
2831 }
2832
2833 #include <wx/metafile.h>
2834
2835
2836 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2837
2838
2839 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2841 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2842 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2843 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2844
2845
2846 class wxPyTextDropTarget : public wxTextDropTarget {
2847 public:
2848 wxPyTextDropTarget() {}
2849
2850 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2851
2852 DEC_PYCALLBACK__(OnLeave);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2855 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2856 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2857
2858 PYPRIVATE;
2859 };
2860
2861 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2862 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2865 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2866 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2867
2868
2869
2870 class wxPyFileDropTarget : public wxFileDropTarget {
2871 public:
2872 wxPyFileDropTarget() {}
2873
2874 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2875
2876 DEC_PYCALLBACK__(OnLeave);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2879 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2880 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2881
2882 PYPRIVATE;
2883 };
2884
2885 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2886 const wxArrayString& filenames) {
2887 bool rval = false;
2888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2889 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2890 PyObject* list = wxArrayString2PyList_helper(filenames);
2891 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2892 Py_DECREF(list);
2893 }
2894 wxPyEndBlockThreads(blocked);
2895 return rval;
2896 }
2897
2898
2899
2900 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2903 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2904 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2905
2906
2907
2908
2909 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2910
2911 #include <wx/display.h>
2912
2913 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2914 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2915
2916 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2917 #if !wxUSE_DISPLAY
2918 #include <wx/dynarray.h>
2919 #include <wx/vidmode.h>
2920
2921 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2922 #include "wx/arrimpl.cpp"
2923 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2924 const wxVideoMode wxDefaultVideoMode;
2925
2926 class wxDisplay
2927 {
2928 public:
2929 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2930 ~wxDisplay() {}
2931
2932 static size_t GetCount()
2933 { wxPyRaiseNotImplemented(); return 0; }
2934
2935 static int GetFromPoint(const wxPoint& pt)
2936 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2937 static int GetFromWindow(wxWindow *window)
2938 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2939
2940 virtual bool IsOk() const { return false; }
2941 virtual wxRect GetGeometry() const { wxRect r; return r; }
2942 virtual wxString GetName() const { return wxEmptyString; }
2943 bool IsPrimary() const { return false; }
2944
2945 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2946 { wxArrayVideoModes a; return a; }
2947
2948 virtual wxVideoMode GetCurrentMode() const
2949 { return wxDefaultVideoMode; }
2950
2951 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2952 { return false; }
2953
2954 void ResetMode() {}
2955 };
2956 #endif
2957
2958 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2959 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2960 PyObject* pyList = NULL;
2961 wxArrayVideoModes arr = self->GetModes(mode);
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2963 pyList = PyList_New(0);
2964 for (int i=0; i < arr.GetCount(); i++) {
2965 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2966 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2967 PyList_Append(pyList, pyObj);
2968 Py_DECREF(pyObj);
2969 }
2970 wxPyEndBlockThreads(blocked);
2971 return pyList;
2972 }
2973
2974 #include <wx/stdpaths.h>
2975
2976 static wxStandardPaths *StandardPaths_Get(){
2977 return (wxStandardPaths*) &wxStandardPaths::Get();
2978 }
2979 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2980 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2981 #ifdef __cplusplus
2982 extern "C" {
2983 #endif
2984 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2985 PyObject *resultobj;
2986 wxSystemColour arg1 ;
2987 wxColour result;
2988 PyObject * obj0 = 0 ;
2989 char *kwnames[] = {
2990 (char *) "index", NULL
2991 };
2992
2993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2994 {
2995 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2996 if (SWIG_arg_fail(1)) SWIG_fail;
2997 }
2998 {
2999 if (!wxPyCheckForApp()) SWIG_fail;
3000 PyThreadState* __tstate = wxPyBeginAllowThreads();
3001 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3002
3003 wxPyEndAllowThreads(__tstate);
3004 if (PyErr_Occurred()) SWIG_fail;
3005 }
3006 {
3007 wxColour * resultptr;
3008 resultptr = new wxColour((wxColour &)(result));
3009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3010 }
3011 return resultobj;
3012 fail:
3013 return NULL;
3014 }
3015
3016
3017 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3018 PyObject *resultobj;
3019 wxSystemFont arg1 ;
3020 wxFont result;
3021 PyObject * obj0 = 0 ;
3022 char *kwnames[] = {
3023 (char *) "index", NULL
3024 };
3025
3026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3027 {
3028 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3029 if (SWIG_arg_fail(1)) SWIG_fail;
3030 }
3031 {
3032 if (!wxPyCheckForApp()) SWIG_fail;
3033 PyThreadState* __tstate = wxPyBeginAllowThreads();
3034 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3035
3036 wxPyEndAllowThreads(__tstate);
3037 if (PyErr_Occurred()) SWIG_fail;
3038 }
3039 {
3040 wxFont * resultptr;
3041 resultptr = new wxFont((wxFont &)(result));
3042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3043 }
3044 return resultobj;
3045 fail:
3046 return NULL;
3047 }
3048
3049
3050 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3051 PyObject *resultobj;
3052 wxSystemMetric arg1 ;
3053 wxWindow *arg2 = (wxWindow *) NULL ;
3054 int result;
3055 PyObject * obj0 = 0 ;
3056 PyObject * obj1 = 0 ;
3057 char *kwnames[] = {
3058 (char *) "index",(char *) "win", NULL
3059 };
3060
3061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3062 {
3063 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3064 if (SWIG_arg_fail(1)) SWIG_fail;
3065 }
3066 if (obj1) {
3067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3068 if (SWIG_arg_fail(2)) SWIG_fail;
3069 }
3070 {
3071 if (!wxPyCheckForApp()) SWIG_fail;
3072 PyThreadState* __tstate = wxPyBeginAllowThreads();
3073 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3074
3075 wxPyEndAllowThreads(__tstate);
3076 if (PyErr_Occurred()) SWIG_fail;
3077 }
3078 {
3079 resultobj = SWIG_From_int((int)(result));
3080 }
3081 return resultobj;
3082 fail:
3083 return NULL;
3084 }
3085
3086
3087 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3088 PyObject *resultobj;
3089 wxSystemFeature arg1 ;
3090 bool result;
3091 PyObject * obj0 = 0 ;
3092 char *kwnames[] = {
3093 (char *) "index", NULL
3094 };
3095
3096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3097 {
3098 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3099 if (SWIG_arg_fail(1)) SWIG_fail;
3100 }
3101 {
3102 if (!wxPyCheckForApp()) SWIG_fail;
3103 PyThreadState* __tstate = wxPyBeginAllowThreads();
3104 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3105
3106 wxPyEndAllowThreads(__tstate);
3107 if (PyErr_Occurred()) SWIG_fail;
3108 }
3109 {
3110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3111 }
3112 return resultobj;
3113 fail:
3114 return NULL;
3115 }
3116
3117
3118 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3119 PyObject *resultobj;
3120 wxSystemScreenType result;
3121 char *kwnames[] = {
3122 NULL
3123 };
3124
3125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3126 {
3127 if (!wxPyCheckForApp()) SWIG_fail;
3128 PyThreadState* __tstate = wxPyBeginAllowThreads();
3129 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3130
3131 wxPyEndAllowThreads(__tstate);
3132 if (PyErr_Occurred()) SWIG_fail;
3133 }
3134 resultobj = SWIG_From_int((result));
3135 return resultobj;
3136 fail:
3137 return NULL;
3138 }
3139
3140
3141 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3142 PyObject *resultobj;
3143 wxSystemScreenType arg1 ;
3144 PyObject * obj0 = 0 ;
3145 char *kwnames[] = {
3146 (char *) "screen", NULL
3147 };
3148
3149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3150 {
3151 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3152 if (SWIG_arg_fail(1)) SWIG_fail;
3153 }
3154 {
3155 if (!wxPyCheckForApp()) SWIG_fail;
3156 PyThreadState* __tstate = wxPyBeginAllowThreads();
3157 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3158
3159 wxPyEndAllowThreads(__tstate);
3160 if (PyErr_Occurred()) SWIG_fail;
3161 }
3162 Py_INCREF(Py_None); resultobj = Py_None;
3163 return resultobj;
3164 fail:
3165 return NULL;
3166 }
3167
3168
3169 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3170 PyObject *obj;
3171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3172 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3173 Py_INCREF(obj);
3174 return Py_BuildValue((char *)"");
3175 }
3176 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3177 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3178 return 1;
3179 }
3180
3181
3182 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3183 PyObject *pyobj;
3184
3185 {
3186 #if wxUSE_UNICODE
3187 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3188 #else
3189 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3190 #endif
3191 }
3192 return pyobj;
3193 }
3194
3195
3196 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3197 PyObject *resultobj;
3198 wxSystemOptions *result;
3199 char *kwnames[] = {
3200 NULL
3201 };
3202
3203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (wxSystemOptions *)new wxSystemOptions();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3212 return resultobj;
3213 fail:
3214 return NULL;
3215 }
3216
3217
3218 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3219 PyObject *resultobj;
3220 wxString *arg1 = 0 ;
3221 wxString *arg2 = 0 ;
3222 bool temp1 = false ;
3223 bool temp2 = false ;
3224 PyObject * obj0 = 0 ;
3225 PyObject * obj1 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "name",(char *) "value", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3231 {
3232 arg1 = wxString_in_helper(obj0);
3233 if (arg1 == NULL) SWIG_fail;
3234 temp1 = true;
3235 }
3236 {
3237 arg2 = wxString_in_helper(obj1);
3238 if (arg2 == NULL) SWIG_fail;
3239 temp2 = true;
3240 }
3241 {
3242 PyThreadState* __tstate = wxPyBeginAllowThreads();
3243 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3244
3245 wxPyEndAllowThreads(__tstate);
3246 if (PyErr_Occurred()) SWIG_fail;
3247 }
3248 Py_INCREF(Py_None); resultobj = Py_None;
3249 {
3250 if (temp1)
3251 delete arg1;
3252 }
3253 {
3254 if (temp2)
3255 delete arg2;
3256 }
3257 return resultobj;
3258 fail:
3259 {
3260 if (temp1)
3261 delete arg1;
3262 }
3263 {
3264 if (temp2)
3265 delete arg2;
3266 }
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxString *arg1 = 0 ;
3274 int arg2 ;
3275 bool temp1 = false ;
3276 PyObject * obj0 = 0 ;
3277 PyObject * obj1 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "name",(char *) "value", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3283 {
3284 arg1 = wxString_in_helper(obj0);
3285 if (arg1 == NULL) SWIG_fail;
3286 temp1 = true;
3287 }
3288 {
3289 arg2 = (int)(SWIG_As_int(obj1));
3290 if (SWIG_arg_fail(2)) SWIG_fail;
3291 }
3292 {
3293 PyThreadState* __tstate = wxPyBeginAllowThreads();
3294 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3295
3296 wxPyEndAllowThreads(__tstate);
3297 if (PyErr_Occurred()) SWIG_fail;
3298 }
3299 Py_INCREF(Py_None); resultobj = Py_None;
3300 {
3301 if (temp1)
3302 delete arg1;
3303 }
3304 return resultobj;
3305 fail:
3306 {
3307 if (temp1)
3308 delete arg1;
3309 }
3310 return NULL;
3311 }
3312
3313
3314 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3315 PyObject *resultobj;
3316 wxString *arg1 = 0 ;
3317 wxString result;
3318 bool temp1 = false ;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "name", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3325 {
3326 arg1 = wxString_in_helper(obj0);
3327 if (arg1 == NULL) SWIG_fail;
3328 temp1 = true;
3329 }
3330 {
3331 PyThreadState* __tstate = wxPyBeginAllowThreads();
3332 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3333
3334 wxPyEndAllowThreads(__tstate);
3335 if (PyErr_Occurred()) SWIG_fail;
3336 }
3337 {
3338 #if wxUSE_UNICODE
3339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3340 #else
3341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3342 #endif
3343 }
3344 {
3345 if (temp1)
3346 delete arg1;
3347 }
3348 return resultobj;
3349 fail:
3350 {
3351 if (temp1)
3352 delete arg1;
3353 }
3354 return NULL;
3355 }
3356
3357
3358 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj;
3360 wxString *arg1 = 0 ;
3361 int result;
3362 bool temp1 = false ;
3363 PyObject * obj0 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "name", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3369 {
3370 arg1 = wxString_in_helper(obj0);
3371 if (arg1 == NULL) SWIG_fail;
3372 temp1 = true;
3373 }
3374 {
3375 PyThreadState* __tstate = wxPyBeginAllowThreads();
3376 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3377
3378 wxPyEndAllowThreads(__tstate);
3379 if (PyErr_Occurred()) SWIG_fail;
3380 }
3381 {
3382 resultobj = SWIG_From_int((int)(result));
3383 }
3384 {
3385 if (temp1)
3386 delete arg1;
3387 }
3388 return resultobj;
3389 fail:
3390 {
3391 if (temp1)
3392 delete arg1;
3393 }
3394 return NULL;
3395 }
3396
3397
3398 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3399 PyObject *resultobj;
3400 wxString *arg1 = 0 ;
3401 bool result;
3402 bool temp1 = false ;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "name", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3409 {
3410 arg1 = wxString_in_helper(obj0);
3411 if (arg1 == NULL) SWIG_fail;
3412 temp1 = true;
3413 }
3414 {
3415 PyThreadState* __tstate = wxPyBeginAllowThreads();
3416 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3417
3418 wxPyEndAllowThreads(__tstate);
3419 if (PyErr_Occurred()) SWIG_fail;
3420 }
3421 {
3422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3423 }
3424 {
3425 if (temp1)
3426 delete arg1;
3427 }
3428 return resultobj;
3429 fail:
3430 {
3431 if (temp1)
3432 delete arg1;
3433 }
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 wxString *arg1 = 0 ;
3441 bool result;
3442 bool temp1 = false ;
3443 PyObject * obj0 = 0 ;
3444 char *kwnames[] = {
3445 (char *) "name", NULL
3446 };
3447
3448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3449 {
3450 arg1 = wxString_in_helper(obj0);
3451 if (arg1 == NULL) SWIG_fail;
3452 temp1 = true;
3453 }
3454 {
3455 PyThreadState* __tstate = wxPyBeginAllowThreads();
3456 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3457
3458 wxPyEndAllowThreads(__tstate);
3459 if (PyErr_Occurred()) SWIG_fail;
3460 }
3461 {
3462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3463 }
3464 {
3465 if (temp1)
3466 delete arg1;
3467 }
3468 return resultobj;
3469 fail:
3470 {
3471 if (temp1)
3472 delete arg1;
3473 }
3474 return NULL;
3475 }
3476
3477
3478 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3479 PyObject *obj;
3480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3481 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3482 Py_INCREF(obj);
3483 return Py_BuildValue((char *)"");
3484 }
3485 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3486 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3487 return 1;
3488 }
3489
3490
3491 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3492 PyObject *pyobj;
3493
3494 {
3495 #if wxUSE_UNICODE
3496 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3497 #else
3498 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3499 #endif
3500 }
3501 return pyobj;
3502 }
3503
3504
3505 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3506 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3507 return 1;
3508 }
3509
3510
3511 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3512 PyObject *pyobj;
3513
3514 {
3515 #if wxUSE_UNICODE
3516 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3517 #else
3518 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3519 #endif
3520 }
3521 return pyobj;
3522 }
3523
3524
3525 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3526 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3527 return 1;
3528 }
3529
3530
3531 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3532 PyObject *pyobj;
3533
3534 {
3535 #if wxUSE_UNICODE
3536 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3537 #else
3538 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3539 #endif
3540 }
3541 return pyobj;
3542 }
3543
3544
3545 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 long result;
3548 char *kwnames[] = {
3549 NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (long)wxNewId();
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 resultobj = SWIG_From_long((long)(result));
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 long arg1 ;
3572 PyObject * obj0 = 0 ;
3573 char *kwnames[] = {
3574 (char *) "id", NULL
3575 };
3576
3577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3578 {
3579 arg1 = (long)(SWIG_As_long(obj0));
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 }
3582 {
3583 PyThreadState* __tstate = wxPyBeginAllowThreads();
3584 wxRegisterId(arg1);
3585
3586 wxPyEndAllowThreads(__tstate);
3587 if (PyErr_Occurred()) SWIG_fail;
3588 }
3589 Py_INCREF(Py_None); resultobj = Py_None;
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 long result;
3599 char *kwnames[] = {
3600 NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (long)wxGetCurrentId();
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = SWIG_From_long((long)(result));
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3621 PyObject *resultobj;
3622 int arg1 ;
3623 bool result;
3624 PyObject * obj0 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "id", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3630 {
3631 arg1 = (int)(SWIG_As_int(obj0));
3632 if (SWIG_arg_fail(1)) SWIG_fail;
3633 }
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxIsStockID(arg1);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 int arg1 ;
3653 wxString *arg2 = 0 ;
3654 bool result;
3655 bool temp2 = false ;
3656 PyObject * obj0 = 0 ;
3657 PyObject * obj1 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "id",(char *) "label", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3663 {
3664 arg1 = (int)(SWIG_As_int(obj0));
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 }
3667 {
3668 arg2 = wxString_in_helper(obj1);
3669 if (arg2 == NULL) SWIG_fail;
3670 temp2 = true;
3671 }
3672 {
3673 PyThreadState* __tstate = wxPyBeginAllowThreads();
3674 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3675
3676 wxPyEndAllowThreads(__tstate);
3677 if (PyErr_Occurred()) SWIG_fail;
3678 }
3679 {
3680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3681 }
3682 {
3683 if (temp2)
3684 delete arg2;
3685 }
3686 return resultobj;
3687 fail:
3688 {
3689 if (temp2)
3690 delete arg2;
3691 }
3692 return NULL;
3693 }
3694
3695
3696 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3697 PyObject *resultobj;
3698 int arg1 ;
3699 bool arg2 = (bool) true ;
3700 wxString arg3 = (wxString) wxPyEmptyString ;
3701 wxString result;
3702 PyObject * obj0 = 0 ;
3703 PyObject * obj1 = 0 ;
3704 PyObject * obj2 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3710 {
3711 arg1 = (int)(SWIG_As_int(obj0));
3712 if (SWIG_arg_fail(1)) SWIG_fail;
3713 }
3714 if (obj1) {
3715 {
3716 arg2 = (bool)(SWIG_As_bool(obj1));
3717 if (SWIG_arg_fail(2)) SWIG_fail;
3718 }
3719 }
3720 if (obj2) {
3721 {
3722 wxString* sptr = wxString_in_helper(obj2);
3723 if (sptr == NULL) SWIG_fail;
3724 arg3 = *sptr;
3725 delete sptr;
3726 }
3727 }
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 result = wxGetStockLabel(arg1,arg2,arg3);
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 {
3736 #if wxUSE_UNICODE
3737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3738 #else
3739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3740 #endif
3741 }
3742 return resultobj;
3743 fail:
3744 return NULL;
3745 }
3746
3747
3748 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3749 PyObject *resultobj;
3750 char *kwnames[] = {
3751 NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3755 {
3756 if (!wxPyCheckForApp()) SWIG_fail;
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 wxBell();
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 char *kwnames[] = {
3773 NULL
3774 };
3775
3776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3777 {
3778 if (!wxPyCheckForApp()) SWIG_fail;
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 wxEndBusyCursor();
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 Py_INCREF(Py_None); resultobj = Py_None;
3786 return resultobj;
3787 fail:
3788 return NULL;
3789 }
3790
3791
3792 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3793 PyObject *resultobj;
3794 bool arg1 = (bool) true ;
3795 long result;
3796 PyObject * obj0 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "resetTimer", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3802 if (obj0) {
3803 {
3804 arg1 = (bool)(SWIG_As_bool(obj0));
3805 if (SWIG_arg_fail(1)) SWIG_fail;
3806 }
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (long)wxGetElapsedTime(arg1);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_long((long)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 int *arg1 = (int *) 0 ;
3827 int *arg2 = (int *) 0 ;
3828 int temp1 ;
3829 int res1 = 0 ;
3830 int temp2 ;
3831 int res2 = 0 ;
3832 char *kwnames[] = {
3833 NULL
3834 };
3835
3836 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3837 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3839 {
3840 if (!wxPyCheckForApp()) SWIG_fail;
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 wxGetMousePosition(arg1,arg2);
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 Py_INCREF(Py_None); resultobj = Py_None;
3848 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3849 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3850 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3851 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3852 return resultobj;
3853 fail:
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj;
3860 bool result;
3861 char *kwnames[] = {
3862 NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 result = (bool)wxIsBusy();
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxString result;
3885 char *kwnames[] = {
3886 NULL
3887 };
3888
3889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = wxNow();
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 #if wxUSE_UNICODE
3899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3900 #else
3901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3902 #endif
3903 }
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxString const &arg1_defvalue = wxPyEmptyString ;
3913 wxString *arg1 = (wxString *) &arg1_defvalue ;
3914 bool result;
3915 bool temp1 = false ;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "command", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3922 if (obj0) {
3923 {
3924 arg1 = wxString_in_helper(obj0);
3925 if (arg1 == NULL) SWIG_fail;
3926 temp1 = true;
3927 }
3928 }
3929 {
3930 PyThreadState* __tstate = wxPyBeginAllowThreads();
3931 result = (bool)wxShell((wxString const &)*arg1);
3932
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 {
3937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3938 }
3939 {
3940 if (temp1)
3941 delete arg1;
3942 }
3943 return resultobj;
3944 fail:
3945 {
3946 if (temp1)
3947 delete arg1;
3948 }
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj;
3955 char *kwnames[] = {
3956 NULL
3957 };
3958
3959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 wxStartTimer();
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 Py_INCREF(Py_None); resultobj = Py_None;
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 int *arg1 = (int *) 0 ;
3977 int *arg2 = (int *) 0 ;
3978 int result;
3979 int temp1 ;
3980 int res1 = 0 ;
3981 int temp2 ;
3982 int res2 = 0 ;
3983 char *kwnames[] = {
3984 NULL
3985 };
3986
3987 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3988 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3990 {
3991 PyThreadState* __tstate = wxPyBeginAllowThreads();
3992 result = (int)wxGetOsVersion(arg1,arg2);
3993
3994 wxPyEndAllowThreads(__tstate);
3995 if (PyErr_Occurred()) SWIG_fail;
3996 }
3997 {
3998 resultobj = SWIG_From_int((int)(result));
3999 }
4000 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4001 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4002 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4003 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj;
4012 wxString result;
4013 char *kwnames[] = {
4014 NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = wxGetOsDescription();
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 {
4026 #if wxUSE_UNICODE
4027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4028 #else
4029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4030 #endif
4031 }
4032 return resultobj;
4033 fail:
4034 return NULL;
4035 }
4036
4037
4038 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4039 PyObject *resultobj;
4040 long result;
4041 char *kwnames[] = {
4042 NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4046 {
4047 PyThreadState* __tstate = wxPyBeginAllowThreads();
4048 result = (long)wxGetFreeMemory();
4049
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 {
4054 resultobj = SWIG_From_long((long)(result));
4055 }
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 wxShutdownFlags arg1 ;
4065 bool result;
4066 PyObject * obj0 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "wFlags", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4072 {
4073 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4074 if (SWIG_arg_fail(1)) SWIG_fail;
4075 }
4076 {
4077 if (!wxPyCheckForApp()) SWIG_fail;
4078 PyThreadState* __tstate = wxPyBeginAllowThreads();
4079 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4080
4081 wxPyEndAllowThreads(__tstate);
4082 if (PyErr_Occurred()) SWIG_fail;
4083 }
4084 {
4085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4086 }
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 int arg1 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "secs", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4102 {
4103 arg1 = (int)(SWIG_As_int(obj0));
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 }
4106 {
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 wxSleep(arg1);
4109
4110 wxPyEndAllowThreads(__tstate);
4111 if (PyErr_Occurred()) SWIG_fail;
4112 }
4113 Py_INCREF(Py_None); resultobj = Py_None;
4114 return resultobj;
4115 fail:
4116 return NULL;
4117 }
4118
4119
4120 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4121 PyObject *resultobj;
4122 unsigned long arg1 ;
4123 PyObject * obj0 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "milliseconds", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4129 {
4130 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4131 if (SWIG_arg_fail(1)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 wxMilliSleep(arg1);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 Py_INCREF(Py_None); resultobj = Py_None;
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 unsigned long arg1 ;
4150 PyObject * obj0 = 0 ;
4151 char *kwnames[] = {
4152 (char *) "microseconds", NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4156 {
4157 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 wxMicroSleep(arg1);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 Py_INCREF(Py_None); resultobj = Py_None;
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 bool arg1 ;
4177 PyObject * obj0 = 0 ;
4178 char *kwnames[] = {
4179 (char *) "enable", NULL
4180 };
4181
4182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4183 {
4184 arg1 = (bool)(SWIG_As_bool(obj0));
4185 if (SWIG_arg_fail(1)) SWIG_fail;
4186 }
4187 {
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 wxEnableTopLevelWindows(arg1);
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 Py_INCREF(Py_None); resultobj = Py_None;
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 wxString *arg1 = 0 ;
4204 wxString result;
4205 bool temp1 = false ;
4206 PyObject * obj0 = 0 ;
4207 char *kwnames[] = {
4208 (char *) "in", NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4212 {
4213 arg1 = wxString_in_helper(obj0);
4214 if (arg1 == NULL) SWIG_fail;
4215 temp1 = true;
4216 }
4217 {
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = wxStripMenuCodes((wxString const &)*arg1);
4220
4221 wxPyEndAllowThreads(__tstate);
4222 if (PyErr_Occurred()) SWIG_fail;
4223 }
4224 {
4225 #if wxUSE_UNICODE
4226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4227 #else
4228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4229 #endif
4230 }
4231 {
4232 if (temp1)
4233 delete arg1;
4234 }
4235 return resultobj;
4236 fail:
4237 {
4238 if (temp1)
4239 delete arg1;
4240 }
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 wxString result;
4248 char *kwnames[] = {
4249 NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 result = wxGetEmailAddress();
4256
4257 wxPyEndAllowThreads(__tstate);
4258 if (PyErr_Occurred()) SWIG_fail;
4259 }
4260 {
4261 #if wxUSE_UNICODE
4262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4263 #else
4264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4265 #endif
4266 }
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4274 PyObject *resultobj;
4275 wxString result;
4276 char *kwnames[] = {
4277 NULL
4278 };
4279
4280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 result = wxGetHostName();
4284
4285 wxPyEndAllowThreads(__tstate);
4286 if (PyErr_Occurred()) SWIG_fail;
4287 }
4288 {
4289 #if wxUSE_UNICODE
4290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4291 #else
4292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4293 #endif
4294 }
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj;
4303 wxString result;
4304 char *kwnames[] = {
4305 NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = wxGetFullHostName();
4312
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 {
4317 #if wxUSE_UNICODE
4318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4319 #else
4320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4321 #endif
4322 }
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4330 PyObject *resultobj;
4331 wxString result;
4332 char *kwnames[] = {
4333 NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4337 {
4338 PyThreadState* __tstate = wxPyBeginAllowThreads();
4339 result = wxGetUserId();
4340
4341 wxPyEndAllowThreads(__tstate);
4342 if (PyErr_Occurred()) SWIG_fail;
4343 }
4344 {
4345 #if wxUSE_UNICODE
4346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4347 #else
4348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4349 #endif
4350 }
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4358 PyObject *resultobj;
4359 wxString result;
4360 char *kwnames[] = {
4361 NULL
4362 };
4363
4364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4365 {
4366 PyThreadState* __tstate = wxPyBeginAllowThreads();
4367 result = wxGetUserName();
4368
4369 wxPyEndAllowThreads(__tstate);
4370 if (PyErr_Occurred()) SWIG_fail;
4371 }
4372 {
4373 #if wxUSE_UNICODE
4374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4375 #else
4376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4377 #endif
4378 }
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj;
4387 wxString result;
4388 char *kwnames[] = {
4389 NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxGetHomeDir();
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj;
4415 wxString const &arg1_defvalue = wxPyEmptyString ;
4416 wxString *arg1 = (wxString *) &arg1_defvalue ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char *kwnames[] = {
4421 (char *) "user", NULL
4422 };
4423
4424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4425 if (obj0) {
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 }
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = wxGetUserHome((wxString const &)*arg1);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 {
4440 #if wxUSE_UNICODE
4441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4442 #else
4443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4444 #endif
4445 }
4446 {
4447 if (temp1)
4448 delete arg1;
4449 }
4450 return resultobj;
4451 fail:
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return NULL;
4457 }
4458
4459
4460 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4461 PyObject *resultobj;
4462 unsigned long result;
4463 char *kwnames[] = {
4464 NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4468 {
4469 PyThreadState* __tstate = wxPyBeginAllowThreads();
4470 result = (unsigned long)wxGetProcessId();
4471
4472 wxPyEndAllowThreads(__tstate);
4473 if (PyErr_Occurred()) SWIG_fail;
4474 }
4475 {
4476 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4477 }
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4485 PyObject *resultobj;
4486 char *kwnames[] = {
4487 NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 wxTrap();
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 Py_INCREF(Py_None); resultobj = Py_None;
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj;
4507 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4508 wxString *arg1 = (wxString *) &arg1_defvalue ;
4509 wxString const &arg2_defvalue = wxPyEmptyString ;
4510 wxString *arg2 = (wxString *) &arg2_defvalue ;
4511 wxString const &arg3_defvalue = wxPyEmptyString ;
4512 wxString *arg3 = (wxString *) &arg3_defvalue ;
4513 wxString const &arg4_defvalue = wxPyEmptyString ;
4514 wxString *arg4 = (wxString *) &arg4_defvalue ;
4515 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4516 wxString *arg5 = (wxString *) &arg5_defvalue ;
4517 int arg6 = (int) 0 ;
4518 wxWindow *arg7 = (wxWindow *) NULL ;
4519 int arg8 = (int) -1 ;
4520 int arg9 = (int) -1 ;
4521 wxString result;
4522 bool temp1 = false ;
4523 bool temp2 = false ;
4524 bool temp3 = false ;
4525 bool temp4 = false ;
4526 bool temp5 = false ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 PyObject * obj2 = 0 ;
4530 PyObject * obj3 = 0 ;
4531 PyObject * obj4 = 0 ;
4532 PyObject * obj5 = 0 ;
4533 PyObject * obj6 = 0 ;
4534 PyObject * obj7 = 0 ;
4535 PyObject * obj8 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4541 if (obj0) {
4542 {
4543 arg1 = wxString_in_helper(obj0);
4544 if (arg1 == NULL) SWIG_fail;
4545 temp1 = true;
4546 }
4547 }
4548 if (obj1) {
4549 {
4550 arg2 = wxString_in_helper(obj1);
4551 if (arg2 == NULL) SWIG_fail;
4552 temp2 = true;
4553 }
4554 }
4555 if (obj2) {
4556 {
4557 arg3 = wxString_in_helper(obj2);
4558 if (arg3 == NULL) SWIG_fail;
4559 temp3 = true;
4560 }
4561 }
4562 if (obj3) {
4563 {
4564 arg4 = wxString_in_helper(obj3);
4565 if (arg4 == NULL) SWIG_fail;
4566 temp4 = true;
4567 }
4568 }
4569 if (obj4) {
4570 {
4571 arg5 = wxString_in_helper(obj4);
4572 if (arg5 == NULL) SWIG_fail;
4573 temp5 = true;
4574 }
4575 }
4576 if (obj5) {
4577 {
4578 arg6 = (int)(SWIG_As_int(obj5));
4579 if (SWIG_arg_fail(6)) SWIG_fail;
4580 }
4581 }
4582 if (obj6) {
4583 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4584 if (SWIG_arg_fail(7)) SWIG_fail;
4585 }
4586 if (obj7) {
4587 {
4588 arg8 = (int)(SWIG_As_int(obj7));
4589 if (SWIG_arg_fail(8)) SWIG_fail;
4590 }
4591 }
4592 if (obj8) {
4593 {
4594 arg9 = (int)(SWIG_As_int(obj8));
4595 if (SWIG_arg_fail(9)) SWIG_fail;
4596 }
4597 }
4598 {
4599 if (!wxPyCheckForApp()) SWIG_fail;
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4602
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 {
4607 #if wxUSE_UNICODE
4608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4609 #else
4610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4611 #endif
4612 }
4613 {
4614 if (temp1)
4615 delete arg1;
4616 }
4617 {
4618 if (temp2)
4619 delete arg2;
4620 }
4621 {
4622 if (temp3)
4623 delete arg3;
4624 }
4625 {
4626 if (temp4)
4627 delete arg4;
4628 }
4629 {
4630 if (temp5)
4631 delete arg5;
4632 }
4633 return resultobj;
4634 fail:
4635 {
4636 if (temp1)
4637 delete arg1;
4638 }
4639 {
4640 if (temp2)
4641 delete arg2;
4642 }
4643 {
4644 if (temp3)
4645 delete arg3;
4646 }
4647 {
4648 if (temp4)
4649 delete arg4;
4650 }
4651 {
4652 if (temp5)
4653 delete arg5;
4654 }
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj;
4661 wxString *arg1 = 0 ;
4662 wxString *arg2 = 0 ;
4663 wxString const &arg3_defvalue = wxPyEmptyString ;
4664 wxString *arg3 = (wxString *) &arg3_defvalue ;
4665 wxWindow *arg4 = (wxWindow *) NULL ;
4666 wxString result;
4667 bool temp1 = false ;
4668 bool temp2 = false ;
4669 bool temp3 = false ;
4670 PyObject * obj0 = 0 ;
4671 PyObject * obj1 = 0 ;
4672 PyObject * obj2 = 0 ;
4673 PyObject * obj3 = 0 ;
4674 char *kwnames[] = {
4675 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4676 };
4677
4678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4679 {
4680 arg1 = wxString_in_helper(obj0);
4681 if (arg1 == NULL) SWIG_fail;
4682 temp1 = true;
4683 }
4684 {
4685 arg2 = wxString_in_helper(obj1);
4686 if (arg2 == NULL) SWIG_fail;
4687 temp2 = true;
4688 }
4689 if (obj2) {
4690 {
4691 arg3 = wxString_in_helper(obj2);
4692 if (arg3 == NULL) SWIG_fail;
4693 temp3 = true;
4694 }
4695 }
4696 if (obj3) {
4697 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(4)) SWIG_fail;
4699 }
4700 {
4701 if (!wxPyCheckForApp()) SWIG_fail;
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4704
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 {
4709 #if wxUSE_UNICODE
4710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4711 #else
4712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4713 #endif
4714 }
4715 {
4716 if (temp1)
4717 delete arg1;
4718 }
4719 {
4720 if (temp2)
4721 delete arg2;
4722 }
4723 {
4724 if (temp3)
4725 delete arg3;
4726 }
4727 return resultobj;
4728 fail:
4729 {
4730 if (temp1)
4731 delete arg1;
4732 }
4733 {
4734 if (temp2)
4735 delete arg2;
4736 }
4737 {
4738 if (temp3)
4739 delete arg3;
4740 }
4741 return NULL;
4742 }
4743
4744
4745 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj;
4747 wxString *arg1 = 0 ;
4748 wxString *arg2 = 0 ;
4749 wxString const &arg3_defvalue = wxPyEmptyString ;
4750 wxString *arg3 = (wxString *) &arg3_defvalue ;
4751 wxWindow *arg4 = (wxWindow *) NULL ;
4752 wxString result;
4753 bool temp1 = false ;
4754 bool temp2 = false ;
4755 bool temp3 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 PyObject * obj2 = 0 ;
4759 PyObject * obj3 = 0 ;
4760 char *kwnames[] = {
4761 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4762 };
4763
4764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4765 {
4766 arg1 = wxString_in_helper(obj0);
4767 if (arg1 == NULL) SWIG_fail;
4768 temp1 = true;
4769 }
4770 {
4771 arg2 = wxString_in_helper(obj1);
4772 if (arg2 == NULL) SWIG_fail;
4773 temp2 = true;
4774 }
4775 if (obj2) {
4776 {
4777 arg3 = wxString_in_helper(obj2);
4778 if (arg3 == NULL) SWIG_fail;
4779 temp3 = true;
4780 }
4781 }
4782 if (obj3) {
4783 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4784 if (SWIG_arg_fail(4)) SWIG_fail;
4785 }
4786 {
4787 if (!wxPyCheckForApp()) SWIG_fail;
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4790
4791 wxPyEndAllowThreads(__tstate);
4792 if (PyErr_Occurred()) SWIG_fail;
4793 }
4794 {
4795 #if wxUSE_UNICODE
4796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4797 #else
4798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4799 #endif
4800 }
4801 {
4802 if (temp1)
4803 delete arg1;
4804 }
4805 {
4806 if (temp2)
4807 delete arg2;
4808 }
4809 {
4810 if (temp3)
4811 delete arg3;
4812 }
4813 return resultobj;
4814 fail:
4815 {
4816 if (temp1)
4817 delete arg1;
4818 }
4819 {
4820 if (temp2)
4821 delete arg2;
4822 }
4823 {
4824 if (temp3)
4825 delete arg3;
4826 }
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4834 wxString *arg1 = (wxString *) &arg1_defvalue ;
4835 wxString const &arg2_defvalue = wxPyEmptyString ;
4836 wxString *arg2 = (wxString *) &arg2_defvalue ;
4837 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4838 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4839 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4840 wxWindow *arg5 = (wxWindow *) NULL ;
4841 wxString result;
4842 bool temp1 = false ;
4843 bool temp2 = false ;
4844 wxPoint temp4 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 PyObject * obj3 = 0 ;
4849 PyObject * obj4 = 0 ;
4850 char *kwnames[] = {
4851 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4852 };
4853
4854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855 if (obj0) {
4856 {
4857 arg1 = wxString_in_helper(obj0);
4858 if (arg1 == NULL) SWIG_fail;
4859 temp1 = true;
4860 }
4861 }
4862 if (obj1) {
4863 {
4864 arg2 = wxString_in_helper(obj1);
4865 if (arg2 == NULL) SWIG_fail;
4866 temp2 = true;
4867 }
4868 }
4869 if (obj2) {
4870 {
4871 arg3 = (long)(SWIG_As_long(obj2));
4872 if (SWIG_arg_fail(3)) SWIG_fail;
4873 }
4874 }
4875 if (obj3) {
4876 {
4877 arg4 = &temp4;
4878 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4879 }
4880 }
4881 if (obj4) {
4882 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4883 if (SWIG_arg_fail(5)) SWIG_fail;
4884 }
4885 {
4886 if (!wxPyCheckForApp()) SWIG_fail;
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 {
4894 #if wxUSE_UNICODE
4895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4896 #else
4897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4898 #endif
4899 }
4900 {
4901 if (temp1)
4902 delete arg1;
4903 }
4904 {
4905 if (temp2)
4906 delete arg2;
4907 }
4908 return resultobj;
4909 fail:
4910 {
4911 if (temp1)
4912 delete arg1;
4913 }
4914 {
4915 if (temp2)
4916 delete arg2;
4917 }
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxString *arg1 = 0 ;
4925 wxString const &arg2_defvalue = wxPyEmptyString ;
4926 wxString *arg2 = (wxString *) &arg2_defvalue ;
4927 wxString const &arg3_defvalue = wxPyEmptyString ;
4928 wxString *arg3 = (wxString *) &arg3_defvalue ;
4929 wxWindow *arg4 = (wxWindow *) NULL ;
4930 int arg5 = (int) -1 ;
4931 int arg6 = (int) -1 ;
4932 bool arg7 = (bool) true ;
4933 wxString result;
4934 bool temp1 = false ;
4935 bool temp2 = false ;
4936 bool temp3 = false ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 PyObject * obj3 = 0 ;
4941 PyObject * obj4 = 0 ;
4942 PyObject * obj5 = 0 ;
4943 PyObject * obj6 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4949 {
4950 arg1 = wxString_in_helper(obj0);
4951 if (arg1 == NULL) SWIG_fail;
4952 temp1 = true;
4953 }
4954 if (obj1) {
4955 {
4956 arg2 = wxString_in_helper(obj1);
4957 if (arg2 == NULL) SWIG_fail;
4958 temp2 = true;
4959 }
4960 }
4961 if (obj2) {
4962 {
4963 arg3 = wxString_in_helper(obj2);
4964 if (arg3 == NULL) SWIG_fail;
4965 temp3 = true;
4966 }
4967 }
4968 if (obj3) {
4969 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(4)) SWIG_fail;
4971 }
4972 if (obj4) {
4973 {
4974 arg5 = (int)(SWIG_As_int(obj4));
4975 if (SWIG_arg_fail(5)) SWIG_fail;
4976 }
4977 }
4978 if (obj5) {
4979 {
4980 arg6 = (int)(SWIG_As_int(obj5));
4981 if (SWIG_arg_fail(6)) SWIG_fail;
4982 }
4983 }
4984 if (obj6) {
4985 {
4986 arg7 = (bool)(SWIG_As_bool(obj6));
4987 if (SWIG_arg_fail(7)) SWIG_fail;
4988 }
4989 }
4990 {
4991 if (!wxPyCheckForApp()) SWIG_fail;
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 {
4999 #if wxUSE_UNICODE
5000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5001 #else
5002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5003 #endif
5004 }
5005 {
5006 if (temp1)
5007 delete arg1;
5008 }
5009 {
5010 if (temp2)
5011 delete arg2;
5012 }
5013 {
5014 if (temp3)
5015 delete arg3;
5016 }
5017 return resultobj;
5018 fail:
5019 {
5020 if (temp1)
5021 delete arg1;
5022 }
5023 {
5024 if (temp2)
5025 delete arg2;
5026 }
5027 {
5028 if (temp3)
5029 delete arg3;
5030 }
5031 return NULL;
5032 }
5033
5034
5035 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj;
5037 wxString *arg1 = 0 ;
5038 wxString const &arg2_defvalue = wxPyEmptyString ;
5039 wxString *arg2 = (wxString *) &arg2_defvalue ;
5040 wxString const &arg3_defvalue = wxPyEmptyString ;
5041 wxString *arg3 = (wxString *) &arg3_defvalue ;
5042 wxWindow *arg4 = (wxWindow *) NULL ;
5043 wxString result;
5044 bool temp1 = false ;
5045 bool temp2 = false ;
5046 bool temp3 = false ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 PyObject * obj3 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5056 {
5057 arg1 = wxString_in_helper(obj0);
5058 if (arg1 == NULL) SWIG_fail;
5059 temp1 = true;
5060 }
5061 if (obj1) {
5062 {
5063 arg2 = wxString_in_helper(obj1);
5064 if (arg2 == NULL) SWIG_fail;
5065 temp2 = true;
5066 }
5067 }
5068 if (obj2) {
5069 {
5070 arg3 = wxString_in_helper(obj2);
5071 if (arg3 == NULL) SWIG_fail;
5072 temp3 = true;
5073 }
5074 }
5075 if (obj3) {
5076 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5077 if (SWIG_arg_fail(4)) SWIG_fail;
5078 }
5079 {
5080 if (!wxPyCheckForApp()) SWIG_fail;
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5083
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 {
5088 #if wxUSE_UNICODE
5089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5090 #else
5091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5092 #endif
5093 }
5094 {
5095 if (temp1)
5096 delete arg1;
5097 }
5098 {
5099 if (temp2)
5100 delete arg2;
5101 }
5102 {
5103 if (temp3)
5104 delete arg3;
5105 }
5106 return resultobj;
5107 fail:
5108 {
5109 if (temp1)
5110 delete arg1;
5111 }
5112 {
5113 if (temp2)
5114 delete arg2;
5115 }
5116 {
5117 if (temp3)
5118 delete arg3;
5119 }
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxString *arg1 = 0 ;
5127 wxString *arg2 = 0 ;
5128 int arg3 ;
5129 wxString *arg4 = (wxString *) 0 ;
5130 wxWindow *arg5 = (wxWindow *) NULL ;
5131 int arg6 = (int) -1 ;
5132 int arg7 = (int) -1 ;
5133 bool arg8 = (bool) true ;
5134 int arg9 = (int) 150 ;
5135 int arg10 = (int) 200 ;
5136 wxString result;
5137 bool temp1 = false ;
5138 bool temp2 = false ;
5139 PyObject * obj0 = 0 ;
5140 PyObject * obj1 = 0 ;
5141 PyObject * obj2 = 0 ;
5142 PyObject * obj3 = 0 ;
5143 PyObject * obj4 = 0 ;
5144 PyObject * obj5 = 0 ;
5145 PyObject * obj6 = 0 ;
5146 PyObject * obj7 = 0 ;
5147 PyObject * obj8 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5153 {
5154 arg1 = wxString_in_helper(obj0);
5155 if (arg1 == NULL) SWIG_fail;
5156 temp1 = true;
5157 }
5158 {
5159 arg2 = wxString_in_helper(obj1);
5160 if (arg2 == NULL) SWIG_fail;
5161 temp2 = true;
5162 }
5163 {
5164 arg3 = PyList_Size(obj2);
5165 arg4 = wxString_LIST_helper(obj2);
5166 if (arg4 == NULL) SWIG_fail;
5167 }
5168 if (obj3) {
5169 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(5)) SWIG_fail;
5171 }
5172 if (obj4) {
5173 {
5174 arg6 = (int)(SWIG_As_int(obj4));
5175 if (SWIG_arg_fail(6)) SWIG_fail;
5176 }
5177 }
5178 if (obj5) {
5179 {
5180 arg7 = (int)(SWIG_As_int(obj5));
5181 if (SWIG_arg_fail(7)) SWIG_fail;
5182 }
5183 }
5184 if (obj6) {
5185 {
5186 arg8 = (bool)(SWIG_As_bool(obj6));
5187 if (SWIG_arg_fail(8)) SWIG_fail;
5188 }
5189 }
5190 if (obj7) {
5191 {
5192 arg9 = (int)(SWIG_As_int(obj7));
5193 if (SWIG_arg_fail(9)) SWIG_fail;
5194 }
5195 }
5196 if (obj8) {
5197 {
5198 arg10 = (int)(SWIG_As_int(obj8));
5199 if (SWIG_arg_fail(10)) SWIG_fail;
5200 }
5201 }
5202 {
5203 if (!wxPyCheckForApp()) SWIG_fail;
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5206
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 {
5211 #if wxUSE_UNICODE
5212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5213 #else
5214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5215 #endif
5216 }
5217 {
5218 if (temp1)
5219 delete arg1;
5220 }
5221 {
5222 if (temp2)
5223 delete arg2;
5224 }
5225 {
5226 if (arg4) delete [] arg4;
5227 }
5228 return resultobj;
5229 fail:
5230 {
5231 if (temp1)
5232 delete arg1;
5233 }
5234 {
5235 if (temp2)
5236 delete arg2;
5237 }
5238 {
5239 if (arg4) delete [] arg4;
5240 }
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj;
5247 wxString *arg1 = 0 ;
5248 wxString *arg2 = 0 ;
5249 int arg3 ;
5250 wxString *arg4 = (wxString *) 0 ;
5251 wxWindow *arg5 = (wxWindow *) NULL ;
5252 int arg6 = (int) -1 ;
5253 int arg7 = (int) -1 ;
5254 bool arg8 = (bool) true ;
5255 int arg9 = (int) 150 ;
5256 int arg10 = (int) 200 ;
5257 int result;
5258 bool temp1 = false ;
5259 bool temp2 = false ;
5260 PyObject * obj0 = 0 ;
5261 PyObject * obj1 = 0 ;
5262 PyObject * obj2 = 0 ;
5263 PyObject * obj3 = 0 ;
5264 PyObject * obj4 = 0 ;
5265 PyObject * obj5 = 0 ;
5266 PyObject * obj6 = 0 ;
5267 PyObject * obj7 = 0 ;
5268 PyObject * obj8 = 0 ;
5269 char *kwnames[] = {
5270 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5271 };
5272
5273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5274 {
5275 arg1 = wxString_in_helper(obj0);
5276 if (arg1 == NULL) SWIG_fail;
5277 temp1 = true;
5278 }
5279 {
5280 arg2 = wxString_in_helper(obj1);
5281 if (arg2 == NULL) SWIG_fail;
5282 temp2 = true;
5283 }
5284 {
5285 arg3 = PyList_Size(obj2);
5286 arg4 = wxString_LIST_helper(obj2);
5287 if (arg4 == NULL) SWIG_fail;
5288 }
5289 if (obj3) {
5290 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(5)) SWIG_fail;
5292 }
5293 if (obj4) {
5294 {
5295 arg6 = (int)(SWIG_As_int(obj4));
5296 if (SWIG_arg_fail(6)) SWIG_fail;
5297 }
5298 }
5299 if (obj5) {
5300 {
5301 arg7 = (int)(SWIG_As_int(obj5));
5302 if (SWIG_arg_fail(7)) SWIG_fail;
5303 }
5304 }
5305 if (obj6) {
5306 {
5307 arg8 = (bool)(SWIG_As_bool(obj6));
5308 if (SWIG_arg_fail(8)) SWIG_fail;
5309 }
5310 }
5311 if (obj7) {
5312 {
5313 arg9 = (int)(SWIG_As_int(obj7));
5314 if (SWIG_arg_fail(9)) SWIG_fail;
5315 }
5316 }
5317 if (obj8) {
5318 {
5319 arg10 = (int)(SWIG_As_int(obj8));
5320 if (SWIG_arg_fail(10)) SWIG_fail;
5321 }
5322 }
5323 {
5324 if (!wxPyCheckForApp()) SWIG_fail;
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5327
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 resultobj = SWIG_From_int((int)(result));
5333 }
5334 {
5335 if (temp1)
5336 delete arg1;
5337 }
5338 {
5339 if (temp2)
5340 delete arg2;
5341 }
5342 {
5343 if (arg4) delete [] arg4;
5344 }
5345 return resultobj;
5346 fail:
5347 {
5348 if (temp1)
5349 delete arg1;
5350 }
5351 {
5352 if (temp2)
5353 delete arg2;
5354 }
5355 {
5356 if (arg4) delete [] arg4;
5357 }
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxString *arg1 = 0 ;
5365 wxString const &arg2_defvalue = wxPyEmptyString ;
5366 wxString *arg2 = (wxString *) &arg2_defvalue ;
5367 int arg3 = (int) wxOK|wxCENTRE ;
5368 wxWindow *arg4 = (wxWindow *) NULL ;
5369 int arg5 = (int) -1 ;
5370 int arg6 = (int) -1 ;
5371 int result;
5372 bool temp1 = false ;
5373 bool temp2 = false ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 PyObject * obj2 = 0 ;
5377 PyObject * obj3 = 0 ;
5378 PyObject * obj4 = 0 ;
5379 PyObject * obj5 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5385 {
5386 arg1 = wxString_in_helper(obj0);
5387 if (arg1 == NULL) SWIG_fail;
5388 temp1 = true;
5389 }
5390 if (obj1) {
5391 {
5392 arg2 = wxString_in_helper(obj1);
5393 if (arg2 == NULL) SWIG_fail;
5394 temp2 = true;
5395 }
5396 }
5397 if (obj2) {
5398 {
5399 arg3 = (int)(SWIG_As_int(obj2));
5400 if (SWIG_arg_fail(3)) SWIG_fail;
5401 }
5402 }
5403 if (obj3) {
5404 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(4)) SWIG_fail;
5406 }
5407 if (obj4) {
5408 {
5409 arg5 = (int)(SWIG_As_int(obj4));
5410 if (SWIG_arg_fail(5)) SWIG_fail;
5411 }
5412 }
5413 if (obj5) {
5414 {
5415 arg6 = (int)(SWIG_As_int(obj5));
5416 if (SWIG_arg_fail(6)) SWIG_fail;
5417 }
5418 }
5419 {
5420 if (!wxPyCheckForApp()) SWIG_fail;
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 resultobj = SWIG_From_int((int)(result));
5429 }
5430 {
5431 if (temp1)
5432 delete arg1;
5433 }
5434 {
5435 if (temp2)
5436 delete arg2;
5437 }
5438 return resultobj;
5439 fail:
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 {
5445 if (temp2)
5446 delete arg2;
5447 }
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxString *arg1 = 0 ;
5455 wxString *arg2 = 0 ;
5456 wxString *arg3 = 0 ;
5457 long arg4 ;
5458 long arg5 = (long) 0 ;
5459 long arg6 = (long) 100 ;
5460 wxWindow *arg7 = (wxWindow *) NULL ;
5461 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5462 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5463 long result;
5464 bool temp1 = false ;
5465 bool temp2 = false ;
5466 bool temp3 = false ;
5467 wxPoint temp8 ;
5468 PyObject * obj0 = 0 ;
5469 PyObject * obj1 = 0 ;
5470 PyObject * obj2 = 0 ;
5471 PyObject * obj3 = 0 ;
5472 PyObject * obj4 = 0 ;
5473 PyObject * obj5 = 0 ;
5474 PyObject * obj6 = 0 ;
5475 PyObject * obj7 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5481 {
5482 arg1 = wxString_in_helper(obj0);
5483 if (arg1 == NULL) SWIG_fail;
5484 temp1 = true;
5485 }
5486 {
5487 arg2 = wxString_in_helper(obj1);
5488 if (arg2 == NULL) SWIG_fail;
5489 temp2 = true;
5490 }
5491 {
5492 arg3 = wxString_in_helper(obj2);
5493 if (arg3 == NULL) SWIG_fail;
5494 temp3 = true;
5495 }
5496 {
5497 arg4 = (long)(SWIG_As_long(obj3));
5498 if (SWIG_arg_fail(4)) SWIG_fail;
5499 }
5500 if (obj4) {
5501 {
5502 arg5 = (long)(SWIG_As_long(obj4));
5503 if (SWIG_arg_fail(5)) SWIG_fail;
5504 }
5505 }
5506 if (obj5) {
5507 {
5508 arg6 = (long)(SWIG_As_long(obj5));
5509 if (SWIG_arg_fail(6)) SWIG_fail;
5510 }
5511 }
5512 if (obj6) {
5513 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5514 if (SWIG_arg_fail(7)) SWIG_fail;
5515 }
5516 if (obj7) {
5517 {
5518 arg8 = &temp8;
5519 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5520 }
5521 }
5522 {
5523 if (!wxPyCheckForApp()) SWIG_fail;
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = SWIG_From_long((long)(result));
5532 }
5533 {
5534 if (temp1)
5535 delete arg1;
5536 }
5537 {
5538 if (temp2)
5539 delete arg2;
5540 }
5541 {
5542 if (temp3)
5543 delete arg3;
5544 }
5545 return resultobj;
5546 fail:
5547 {
5548 if (temp1)
5549 delete arg1;
5550 }
5551 {
5552 if (temp2)
5553 delete arg2;
5554 }
5555 {
5556 if (temp3)
5557 delete arg3;
5558 }
5559 return NULL;
5560 }
5561
5562
5563 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5564 PyObject *resultobj;
5565 bool result;
5566 char *kwnames[] = {
5567 NULL
5568 };
5569
5570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5571 {
5572 if (!wxPyCheckForApp()) SWIG_fail;
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (bool)wxColourDisplay();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 int result;
5591 char *kwnames[] = {
5592 NULL
5593 };
5594
5595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5596 {
5597 if (!wxPyCheckForApp()) SWIG_fail;
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 result = (int)wxDisplayDepth();
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 resultobj = SWIG_From_int((int)(result));
5606 }
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj;
5615 int result;
5616 char *kwnames[] = {
5617 NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5621 {
5622 if (!wxPyCheckForApp()) SWIG_fail;
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (int)wxGetDisplayDepth();
5625
5626 wxPyEndAllowThreads(__tstate);
5627 if (PyErr_Occurred()) SWIG_fail;
5628 }
5629 {
5630 resultobj = SWIG_From_int((int)(result));
5631 }
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj;
5640 int *arg1 = (int *) 0 ;
5641 int *arg2 = (int *) 0 ;
5642 int temp1 ;
5643 int res1 = 0 ;
5644 int temp2 ;
5645 int res2 = 0 ;
5646 char *kwnames[] = {
5647 NULL
5648 };
5649
5650 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5651 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5653 {
5654 if (!wxPyCheckForApp()) SWIG_fail;
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 wxDisplaySize(arg1,arg2);
5657
5658 wxPyEndAllowThreads(__tstate);
5659 if (PyErr_Occurred()) SWIG_fail;
5660 }
5661 Py_INCREF(Py_None); resultobj = Py_None;
5662 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5663 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5664 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5665 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj;
5674 wxSize result;
5675 char *kwnames[] = {
5676 NULL
5677 };
5678
5679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5680 {
5681 if (!wxPyCheckForApp()) SWIG_fail;
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 result = wxGetDisplaySize();
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 {
5689 wxSize * resultptr;
5690 resultptr = new wxSize((wxSize &)(result));
5691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5692 }
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj;
5701 int *arg1 = (int *) 0 ;
5702 int *arg2 = (int *) 0 ;
5703 int temp1 ;
5704 int res1 = 0 ;
5705 int temp2 ;
5706 int res2 = 0 ;
5707 char *kwnames[] = {
5708 NULL
5709 };
5710
5711 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5712 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5714 {
5715 if (!wxPyCheckForApp()) SWIG_fail;
5716 PyThreadState* __tstate = wxPyBeginAllowThreads();
5717 wxDisplaySizeMM(arg1,arg2);
5718
5719 wxPyEndAllowThreads(__tstate);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 Py_INCREF(Py_None); resultobj = Py_None;
5723 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5724 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5725 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5726 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxSize result;
5736 char *kwnames[] = {
5737 NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5741 {
5742 if (!wxPyCheckForApp()) SWIG_fail;
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 result = wxGetDisplaySizeMM();
5745
5746 wxPyEndAllowThreads(__tstate);
5747 if (PyErr_Occurred()) SWIG_fail;
5748 }
5749 {
5750 wxSize * resultptr;
5751 resultptr = new wxSize((wxSize &)(result));
5752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5753 }
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj;
5762 int *arg1 = (int *) 0 ;
5763 int *arg2 = (int *) 0 ;
5764 int *arg3 = (int *) 0 ;
5765 int *arg4 = (int *) 0 ;
5766 int temp1 ;
5767 int res1 = 0 ;
5768 int temp2 ;
5769 int res2 = 0 ;
5770 int temp3 ;
5771 int res3 = 0 ;
5772 int temp4 ;
5773 int res4 = 0 ;
5774 char *kwnames[] = {
5775 NULL
5776 };
5777
5778 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5780 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5781 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5783 {
5784 if (!wxPyCheckForApp()) SWIG_fail;
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 Py_INCREF(Py_None); resultobj = Py_None;
5792 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5793 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5794 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5795 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5796 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5797 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5798 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5799 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxRect result;
5809 char *kwnames[] = {
5810 NULL
5811 };
5812
5813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxGetClientDisplayRect();
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 wxRect * resultptr;
5824 resultptr = new wxRect((wxRect &)(result));
5825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxCursor *arg1 = 0 ;
5836 PyObject * obj0 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "cursor", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5842 {
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 if (arg1 == NULL) {
5846 SWIG_null_ref("wxCursor");
5847 }
5848 if (SWIG_arg_fail(1)) SWIG_fail;
5849 }
5850 {
5851 if (!wxPyCheckForApp()) SWIG_fail;
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 wxSetCursor(*arg1);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5868 PyObject * obj0 = 0 ;
5869 char *kwnames[] = {
5870 (char *) "cursor", NULL
5871 };
5872
5873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5874 if (obj0) {
5875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5876 if (SWIG_arg_fail(1)) SWIG_fail;
5877 }
5878 {
5879 if (!wxPyCheckForApp()) SWIG_fail;
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 wxBeginBusyCursor(arg1);
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj;
5895 wxWindow *result;
5896 char *kwnames[] = {
5897 NULL
5898 };
5899
5900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5901 {
5902 if (!wxPyCheckForApp()) SWIG_fail;
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (wxWindow *)wxGetActiveWindow();
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 resultobj = wxPyMake_wxObject(result, 0);
5911 }
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj;
5920 wxPoint *arg1 = 0 ;
5921 wxWindow *result;
5922 wxPoint temp1 ;
5923 PyObject * obj0 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "pt", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5929 {
5930 arg1 = &temp1;
5931 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5932 }
5933 {
5934 if (!wxPyCheckForApp()) SWIG_fail;
5935 PyThreadState* __tstate = wxPyBeginAllowThreads();
5936 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5937
5938 wxPyEndAllowThreads(__tstate);
5939 if (PyErr_Occurred()) SWIG_fail;
5940 }
5941 {
5942 resultobj = wxPyMake_wxObject(result, 0);
5943 }
5944 return resultobj;
5945 fail:
5946 return NULL;
5947 }
5948
5949
5950 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj;
5952 wxPoint *arg1 = 0 ;
5953 wxWindow *result;
5954 wxPoint temp1 ;
5955 PyObject * obj0 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "pt", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5961 {
5962 arg1 = &temp1;
5963 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5964 }
5965 {
5966 if (!wxPyCheckForApp()) SWIG_fail;
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5969
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 {
5974 resultobj = wxPyMake_wxObject(result, 0);
5975 }
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj;
5984 wxWindow *arg1 = (wxWindow *) 0 ;
5985 wxWindow *result;
5986 PyObject * obj0 = 0 ;
5987 char *kwnames[] = {
5988 (char *) "win", NULL
5989 };
5990
5991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5993 if (SWIG_arg_fail(1)) SWIG_fail;
5994 {
5995 if (!wxPyCheckForApp()) SWIG_fail;
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (wxWindow *)wxGetTopLevelParent(arg1);
5998
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 {
6003 resultobj = wxPyMake_wxObject(result, 0);
6004 }
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj;
6013 wxString *arg1 = 0 ;
6014 bool result;
6015 bool temp1 = false ;
6016 PyObject * obj0 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "url", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6022 {
6023 arg1 = wxString_in_helper(obj0);
6024 if (arg1 == NULL) SWIG_fail;
6025 temp1 = true;
6026 }
6027 {
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6030
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 {
6035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6036 }
6037 {
6038 if (temp1)
6039 delete arg1;
6040 }
6041 return resultobj;
6042 fail:
6043 {
6044 if (temp1)
6045 delete arg1;
6046 }
6047 return NULL;
6048 }
6049
6050
6051 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj;
6053 wxKeyCode arg1 ;
6054 bool result;
6055 PyObject * obj0 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "key", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6061 {
6062 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6063 if (SWIG_arg_fail(1)) SWIG_fail;
6064 }
6065 {
6066 if (!wxPyCheckForApp()) SWIG_fail;
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6069
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 {
6074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6075 }
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 char *kwnames[] = {
6085 NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6089 {
6090 if (!wxPyCheckForApp()) SWIG_fail;
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 wxWakeUpMainThread();
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 Py_INCREF(Py_None); resultobj = Py_None;
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj;
6106 char *kwnames[] = {
6107 NULL
6108 };
6109
6110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6111 {
6112 if (!wxPyCheckForApp()) SWIG_fail;
6113 PyThreadState* __tstate = wxPyBeginAllowThreads();
6114 wxMutexGuiEnter();
6115
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 Py_INCREF(Py_None); resultobj = Py_None;
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj;
6128 char *kwnames[] = {
6129 NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 wxMutexGuiLeave();
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 Py_INCREF(Py_None); resultobj = Py_None;
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxMutexGuiLocker *result;
6151 char *kwnames[] = {
6152 NULL
6153 };
6154
6155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6174 PyObject * obj0 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "self", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 {
6183 PyThreadState* __tstate = wxPyBeginAllowThreads();
6184 delete 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 * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6197 PyObject *obj;
6198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6199 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6200 Py_INCREF(obj);
6201 return Py_BuildValue((char *)"");
6202 }
6203 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj;
6205 bool result;
6206 char *kwnames[] = {
6207 NULL
6208 };
6209
6210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6211 {
6212 PyThreadState* __tstate = wxPyBeginAllowThreads();
6213 result = (bool)wxThread_IsMain();
6214
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 {
6219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6220 }
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj;
6229 wxString *arg1 = 0 ;
6230 wxToolTip *result;
6231 bool temp1 = false ;
6232 PyObject * obj0 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "tip", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6238 {
6239 arg1 = wxString_in_helper(obj0);
6240 if (arg1 == NULL) SWIG_fail;
6241 temp1 = true;
6242 }
6243 {
6244 if (!wxPyCheckForApp()) SWIG_fail;
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 {
6252 resultobj = wxPyMake_wxObject(result, 1);
6253 }
6254 {
6255 if (temp1)
6256 delete arg1;
6257 }
6258 return resultobj;
6259 fail:
6260 {
6261 if (temp1)
6262 delete arg1;
6263 }
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxToolTip *arg1 = (wxToolTip *) 0 ;
6271 wxString *arg2 = 0 ;
6272 bool temp2 = false ;
6273 PyObject * obj0 = 0 ;
6274 PyObject * obj1 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "self",(char *) "tip", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6281 if (SWIG_arg_fail(1)) SWIG_fail;
6282 {
6283 arg2 = wxString_in_helper(obj1);
6284 if (arg2 == NULL) SWIG_fail;
6285 temp2 = true;
6286 }
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 (arg1)->SetTip((wxString const &)*arg2);
6290
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 Py_INCREF(Py_None); resultobj = Py_None;
6295 {
6296 if (temp2)
6297 delete arg2;
6298 }
6299 return resultobj;
6300 fail:
6301 {
6302 if (temp2)
6303 delete arg2;
6304 }
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxToolTip *arg1 = (wxToolTip *) 0 ;
6312 wxString result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 result = (arg1)->GetTip();
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 {
6329 #if wxUSE_UNICODE
6330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6331 #else
6332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6333 #endif
6334 }
6335 return resultobj;
6336 fail:
6337 return NULL;
6338 }
6339
6340
6341 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6342 PyObject *resultobj;
6343 wxToolTip *arg1 = (wxToolTip *) 0 ;
6344 wxWindow *result;
6345 PyObject * obj0 = 0 ;
6346 char *kwnames[] = {
6347 (char *) "self", NULL
6348 };
6349
6350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6352 if (SWIG_arg_fail(1)) SWIG_fail;
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 result = (wxWindow *)(arg1)->GetWindow();
6356
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 {
6361 resultobj = wxPyMake_wxObject(result, 0);
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 bool arg1 ;
6372 PyObject * obj0 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "flag", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6378 {
6379 arg1 = (bool)(SWIG_As_bool(obj0));
6380 if (SWIG_arg_fail(1)) SWIG_fail;
6381 }
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 wxToolTip::Enable(arg1);
6385
6386 wxPyEndAllowThreads(__tstate);
6387 if (PyErr_Occurred()) SWIG_fail;
6388 }
6389 Py_INCREF(Py_None); resultobj = Py_None;
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6397 PyObject *resultobj;
6398 long arg1 ;
6399 PyObject * obj0 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "milliseconds", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6405 {
6406 arg1 = (long)(SWIG_As_long(obj0));
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 }
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 wxToolTip::SetDelay(arg1);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 Py_INCREF(Py_None); resultobj = Py_None;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6424 PyObject *obj;
6425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6426 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6427 Py_INCREF(obj);
6428 return Py_BuildValue((char *)"");
6429 }
6430 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 wxWindow *arg1 = (wxWindow *) 0 ;
6433 wxSize *arg2 = 0 ;
6434 wxCaret *result;
6435 wxSize temp2 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "window",(char *) "size", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 arg2 = &temp2;
6447 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6448 }
6449 {
6450 if (!wxPyCheckForApp()) SWIG_fail;
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj;
6466 wxCaret *arg1 = (wxCaret *) 0 ;
6467 PyObject * obj0 = 0 ;
6468 char *kwnames[] = {
6469 (char *) "self", NULL
6470 };
6471
6472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(1)) SWIG_fail;
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 wxCaret_Destroy(arg1);
6478
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 Py_INCREF(Py_None); resultobj = Py_None;
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj;
6491 wxCaret *arg1 = (wxCaret *) 0 ;
6492 bool result;
6493 PyObject * obj0 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "self", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6500 if (SWIG_arg_fail(1)) SWIG_fail;
6501 {
6502 PyThreadState* __tstate = wxPyBeginAllowThreads();
6503 result = (bool)(arg1)->IsOk();
6504
6505 wxPyEndAllowThreads(__tstate);
6506 if (PyErr_Occurred()) SWIG_fail;
6507 }
6508 {
6509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6510 }
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxCaret *arg1 = (wxCaret *) 0 ;
6520 bool result;
6521 PyObject * obj0 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "self", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6528 if (SWIG_arg_fail(1)) SWIG_fail;
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (bool)(arg1)->IsVisible();
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxCaret *arg1 = (wxCaret *) 0 ;
6548 wxPoint result;
6549 PyObject * obj0 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = (arg1)->GetPosition();
6560
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 {
6565 wxPoint * resultptr;
6566 resultptr = new wxPoint((wxPoint &)(result));
6567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6568 }
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6576 PyObject *resultobj;
6577 wxCaret *arg1 = (wxCaret *) 0 ;
6578 int *arg2 = (int *) 0 ;
6579 int *arg3 = (int *) 0 ;
6580 int temp2 ;
6581 int res2 = 0 ;
6582 int temp3 ;
6583 int res3 = 0 ;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6590 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 (arg1)->GetPosition(arg2,arg3);
6597
6598 wxPyEndAllowThreads(__tstate);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 Py_INCREF(Py_None); resultobj = Py_None;
6602 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6603 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6604 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6605 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6613 PyObject *resultobj;
6614 wxCaret *arg1 = (wxCaret *) 0 ;
6615 wxSize result;
6616 PyObject * obj0 = 0 ;
6617 char *kwnames[] = {
6618 (char *) "self", NULL
6619 };
6620
6621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6623 if (SWIG_arg_fail(1)) SWIG_fail;
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 result = (arg1)->GetSize();
6627
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 {
6632 wxSize * resultptr;
6633 resultptr = new wxSize((wxSize &)(result));
6634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6635 }
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj;
6644 wxCaret *arg1 = (wxCaret *) 0 ;
6645 int *arg2 = (int *) 0 ;
6646 int *arg3 = (int *) 0 ;
6647 int temp2 ;
6648 int res2 = 0 ;
6649 int temp3 ;
6650 int res3 = 0 ;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6657 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 {
6662 PyThreadState* __tstate = wxPyBeginAllowThreads();
6663 (arg1)->GetSize(arg2,arg3);
6664
6665 wxPyEndAllowThreads(__tstate);
6666 if (PyErr_Occurred()) SWIG_fail;
6667 }
6668 Py_INCREF(Py_None); resultobj = Py_None;
6669 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6671 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6672 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxCaret *arg1 = (wxCaret *) 0 ;
6682 wxWindow *result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (wxWindow *)(arg1)->GetWindow();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = wxPyMake_wxObject(result, 0);
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxCaret *arg1 = (wxCaret *) 0 ;
6710 int arg2 ;
6711 int arg3 ;
6712 PyObject * obj0 = 0 ;
6713 PyObject * obj1 = 0 ;
6714 PyObject * obj2 = 0 ;
6715 char *kwnames[] = {
6716 (char *) "self",(char *) "x",(char *) "y", NULL
6717 };
6718
6719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6721 if (SWIG_arg_fail(1)) SWIG_fail;
6722 {
6723 arg2 = (int)(SWIG_As_int(obj1));
6724 if (SWIG_arg_fail(2)) SWIG_fail;
6725 }
6726 {
6727 arg3 = (int)(SWIG_As_int(obj2));
6728 if (SWIG_arg_fail(3)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->Move(arg2,arg3);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 Py_INCREF(Py_None); resultobj = Py_None;
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj;
6746 wxCaret *arg1 = (wxCaret *) 0 ;
6747 wxPoint *arg2 = 0 ;
6748 wxPoint temp2 ;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "pt", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = &temp2;
6760 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6761 }
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 (arg1)->Move((wxPoint const &)*arg2);
6765
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 Py_INCREF(Py_None); resultobj = Py_None;
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj;
6778 wxCaret *arg1 = (wxCaret *) 0 ;
6779 int arg2 ;
6780 int arg3 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 PyObject * obj2 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "width",(char *) "height", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 arg2 = (int)(SWIG_As_int(obj1));
6793 if (SWIG_arg_fail(2)) SWIG_fail;
6794 }
6795 {
6796 arg3 = (int)(SWIG_As_int(obj2));
6797 if (SWIG_arg_fail(3)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetSize(arg2,arg3);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 Py_INCREF(Py_None); resultobj = Py_None;
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxCaret *arg1 = (wxCaret *) 0 ;
6816 wxSize *arg2 = 0 ;
6817 wxSize temp2 ;
6818 PyObject * obj0 = 0 ;
6819 PyObject * obj1 = 0 ;
6820 char *kwnames[] = {
6821 (char *) "self",(char *) "size", NULL
6822 };
6823
6824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6826 if (SWIG_arg_fail(1)) SWIG_fail;
6827 {
6828 arg2 = &temp2;
6829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->SetSize((wxSize const &)*arg2);
6834
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 Py_INCREF(Py_None); resultobj = Py_None;
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxCaret *arg1 = (wxCaret *) 0 ;
6848 int arg2 = (int) true ;
6849 PyObject * obj0 = 0 ;
6850 PyObject * obj1 = 0 ;
6851 char *kwnames[] = {
6852 (char *) "self",(char *) "show", NULL
6853 };
6854
6855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6857 if (SWIG_arg_fail(1)) SWIG_fail;
6858 if (obj1) {
6859 {
6860 arg2 = (int)(SWIG_As_int(obj1));
6861 if (SWIG_arg_fail(2)) SWIG_fail;
6862 }
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 (arg1)->Show(arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 Py_INCREF(Py_None); resultobj = Py_None;
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxCaret *arg1 = (wxCaret *) 0 ;
6881 PyObject * obj0 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 (arg1)->Hide();
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 Py_INCREF(Py_None); resultobj = Py_None;
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6904 PyObject *resultobj;
6905 int result;
6906 char *kwnames[] = {
6907 NULL
6908 };
6909
6910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (int)wxCaret::GetBlinkTime();
6914
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 {
6919 resultobj = SWIG_From_int((int)(result));
6920 }
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6928 PyObject *resultobj;
6929 int arg1 ;
6930 PyObject * obj0 = 0 ;
6931 char *kwnames[] = {
6932 (char *) "milliseconds", NULL
6933 };
6934
6935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6936 {
6937 arg1 = (int)(SWIG_As_int(obj0));
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 }
6940 {
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 wxCaret::SetBlinkTime(arg1);
6943
6944 wxPyEndAllowThreads(__tstate);
6945 if (PyErr_Occurred()) SWIG_fail;
6946 }
6947 Py_INCREF(Py_None); resultobj = Py_None;
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6955 PyObject *obj;
6956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6957 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6958 Py_INCREF(obj);
6959 return Py_BuildValue((char *)"");
6960 }
6961 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6964 wxBusyCursor *result;
6965 PyObject * obj0 = 0 ;
6966 char *kwnames[] = {
6967 (char *) "cursor", NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6971 if (obj0) {
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 }
6975 {
6976 if (!wxPyCheckForApp()) SWIG_fail;
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj;
6992 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6993 PyObject * obj0 = 0 ;
6994 char *kwnames[] = {
6995 (char *) "self", NULL
6996 };
6997
6998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7000 if (SWIG_arg_fail(1)) SWIG_fail;
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 delete arg1;
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 Py_INCREF(Py_None); resultobj = Py_None;
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7016 PyObject *obj;
7017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7018 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7019 Py_INCREF(obj);
7020 return Py_BuildValue((char *)"");
7021 }
7022 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7023 PyObject *resultobj;
7024 wxWindow *arg1 = (wxWindow *) NULL ;
7025 wxWindowDisabler *result;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "winToSkip", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7032 if (obj0) {
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 }
7036 {
7037 if (!wxPyCheckForApp()) SWIG_fail;
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7052 PyObject *resultobj;
7053 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7054 PyObject * obj0 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 delete arg1;
7065
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 Py_INCREF(Py_None); resultobj = Py_None;
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7077 PyObject *obj;
7078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7079 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7080 Py_INCREF(obj);
7081 return Py_BuildValue((char *)"");
7082 }
7083 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 wxString *arg1 = 0 ;
7086 wxBusyInfo *result;
7087 bool temp1 = false ;
7088 PyObject * obj0 = 0 ;
7089 char *kwnames[] = {
7090 (char *) "message", NULL
7091 };
7092
7093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7094 {
7095 arg1 = wxString_in_helper(obj0);
7096 if (arg1 == NULL) SWIG_fail;
7097 temp1 = true;
7098 }
7099 {
7100 if (!wxPyCheckForApp()) SWIG_fail;
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7103
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7108 {
7109 if (temp1)
7110 delete arg1;
7111 }
7112 return resultobj;
7113 fail:
7114 {
7115 if (temp1)
7116 delete arg1;
7117 }
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 delete arg1;
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 Py_INCREF(Py_None); resultobj = Py_None;
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7148 PyObject *obj;
7149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7150 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7151 Py_INCREF(obj);
7152 return Py_BuildValue((char *)"");
7153 }
7154 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7155 PyObject *resultobj;
7156 wxStopWatch *result;
7157 char *kwnames[] = {
7158 NULL
7159 };
7160
7161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 result = (wxStopWatch *)new wxStopWatch();
7165
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7177 PyObject *resultobj;
7178 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7179 long arg2 = (long) 0 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char *kwnames[] = {
7183 (char *) "self",(char *) "t0", NULL
7184 };
7185
7186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 if (obj1) {
7190 {
7191 arg2 = (long)(SWIG_As_long(obj1));
7192 if (SWIG_arg_fail(2)) SWIG_fail;
7193 }
7194 }
7195 {
7196 PyThreadState* __tstate = wxPyBeginAllowThreads();
7197 (arg1)->Start(arg2);
7198
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 Py_INCREF(Py_None); resultobj = Py_None;
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7212 PyObject * obj0 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 (arg1)->Pause();
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 (arg1)->Resume();
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 Py_INCREF(Py_None); resultobj = Py_None;
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7262 long result;
7263 PyObject * obj0 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 PyThreadState* __tstate = wxPyBeginAllowThreads();
7273 result = (long)((wxStopWatch const *)arg1)->Time();
7274
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = SWIG_From_long((long)(result));
7280 }
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7288 PyObject *obj;
7289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7290 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7291 Py_INCREF(obj);
7292 return Py_BuildValue((char *)"");
7293 }
7294 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 int arg1 = (int) 9 ;
7297 int arg2 = (int) wxID_FILE1 ;
7298 wxFileHistory *result;
7299 PyObject * obj0 = 0 ;
7300 PyObject * obj1 = 0 ;
7301 char *kwnames[] = {
7302 (char *) "maxFiles",(char *) "idBase", NULL
7303 };
7304
7305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7306 if (obj0) {
7307 {
7308 arg1 = (int)(SWIG_As_int(obj0));
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 }
7311 }
7312 if (obj1) {
7313 {
7314 arg2 = (int)(SWIG_As_int(obj1));
7315 if (SWIG_arg_fail(2)) SWIG_fail;
7316 }
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7321
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj;
7334 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 delete arg1;
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 Py_INCREF(Py_None); resultobj = Py_None;
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj;
7359 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7360 wxString *arg2 = 0 ;
7361 bool temp2 = false ;
7362 PyObject * obj0 = 0 ;
7363 PyObject * obj1 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self",(char *) "file", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 arg2 = wxString_in_helper(obj1);
7373 if (arg2 == NULL) SWIG_fail;
7374 temp2 = true;
7375 }
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 (arg1)->AddFileToHistory((wxString const &)*arg2);
7379
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 Py_INCREF(Py_None); resultobj = Py_None;
7384 {
7385 if (temp2)
7386 delete arg2;
7387 }
7388 return resultobj;
7389 fail:
7390 {
7391 if (temp2)
7392 delete arg2;
7393 }
7394 return NULL;
7395 }
7396
7397
7398 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj;
7400 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7401 int arg2 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self",(char *) "i", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 arg2 = (int)(SWIG_As_int(obj1));
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 }
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 (arg1)->RemoveFileFromHistory(arg2);
7418
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 Py_INCREF(Py_None); resultobj = Py_None;
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7432 int result;
7433 PyObject * obj0 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7444
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 resultobj = SWIG_From_int((int)(result));
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7460 wxMenu *arg2 = (wxMenu *) 0 ;
7461 PyObject * obj0 = 0 ;
7462 PyObject * obj1 = 0 ;
7463 char *kwnames[] = {
7464 (char *) "self",(char *) "menu", NULL
7465 };
7466
7467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7469 if (SWIG_arg_fail(1)) SWIG_fail;
7470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7471 if (SWIG_arg_fail(2)) SWIG_fail;
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->UseMenu(arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 Py_INCREF(Py_None); resultobj = Py_None;
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7489 wxMenu *arg2 = (wxMenu *) 0 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 char *kwnames[] = {
7493 (char *) "self",(char *) "menu", NULL
7494 };
7495
7496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7498 if (SWIG_arg_fail(1)) SWIG_fail;
7499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7500 if (SWIG_arg_fail(2)) SWIG_fail;
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 (arg1)->RemoveMenu(arg2);
7504
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 Py_INCREF(Py_None); resultobj = Py_None;
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7518 wxConfigBase *arg2 = 0 ;
7519 PyObject * obj0 = 0 ;
7520 PyObject * obj1 = 0 ;
7521 char *kwnames[] = {
7522 (char *) "self",(char *) "config", NULL
7523 };
7524
7525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7527 if (SWIG_arg_fail(1)) SWIG_fail;
7528 {
7529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7530 if (SWIG_arg_fail(2)) SWIG_fail;
7531 if (arg2 == NULL) {
7532 SWIG_null_ref("wxConfigBase");
7533 }
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->Load(*arg2);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 Py_INCREF(Py_None); resultobj = Py_None;
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj;
7552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7553 wxConfigBase *arg2 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "config", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(2)) SWIG_fail;
7566 if (arg2 == NULL) {
7567 SWIG_null_ref("wxConfigBase");
7568 }
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 (arg1)->Save(*arg2);
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 Py_INCREF(Py_None); resultobj = Py_None;
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7588 PyObject * obj0 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 (arg1)->AddFilesToMenu();
7599
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 Py_INCREF(Py_None); resultobj = Py_None;
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj;
7612 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7613 wxMenu *arg2 = (wxMenu *) 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char *kwnames[] = {
7617 (char *) "self",(char *) "menu", NULL
7618 };
7619
7620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7622 if (SWIG_arg_fail(1)) SWIG_fail;
7623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7624 if (SWIG_arg_fail(2)) SWIG_fail;
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 (arg1)->AddFilesToMenu(arg2);
7628
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 Py_INCREF(Py_None); resultobj = Py_None;
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj;
7641 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7642 int arg2 ;
7643 wxString result;
7644 PyObject * obj0 = 0 ;
7645 PyObject * obj1 = 0 ;
7646 char *kwnames[] = {
7647 (char *) "self",(char *) "i", NULL
7648 };
7649
7650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7652 if (SWIG_arg_fail(1)) SWIG_fail;
7653 {
7654 arg2 = (int)(SWIG_As_int(obj1));
7655 if (SWIG_arg_fail(2)) SWIG_fail;
7656 }
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7660
7661 wxPyEndAllowThreads(__tstate);
7662 if (PyErr_Occurred()) SWIG_fail;
7663 }
7664 {
7665 #if wxUSE_UNICODE
7666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7667 #else
7668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7669 #endif
7670 }
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj;
7679 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7680 int result;
7681 PyObject * obj0 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (int)((wxFileHistory const *)arg1)->GetCount();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = SWIG_From_int((int)(result));
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7706 PyObject *obj;
7707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7708 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7709 Py_INCREF(obj);
7710 return Py_BuildValue((char *)"");
7711 }
7712 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxString *arg1 = 0 ;
7715 wxString const &arg2_defvalue = wxPyEmptyString ;
7716 wxString *arg2 = (wxString *) &arg2_defvalue ;
7717 wxSingleInstanceChecker *result;
7718 bool temp1 = false ;
7719 bool temp2 = false ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "name",(char *) "path", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7727 {
7728 arg1 = wxString_in_helper(obj0);
7729 if (arg1 == NULL) SWIG_fail;
7730 temp1 = true;
7731 }
7732 if (obj1) {
7733 {
7734 arg2 = wxString_in_helper(obj1);
7735 if (arg2 == NULL) SWIG_fail;
7736 temp2 = true;
7737 }
7738 }
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7747 {
7748 if (temp1)
7749 delete arg1;
7750 }
7751 {
7752 if (temp2)
7753 delete arg2;
7754 }
7755 return resultobj;
7756 fail:
7757 {
7758 if (temp1)
7759 delete arg1;
7760 }
7761 {
7762 if (temp2)
7763 delete arg2;
7764 }
7765 return NULL;
7766 }
7767
7768
7769 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7770 PyObject *resultobj;
7771 wxSingleInstanceChecker *result;
7772 char *kwnames[] = {
7773 NULL
7774 };
7775
7776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7777 {
7778 PyThreadState* __tstate = wxPyBeginAllowThreads();
7779 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7780
7781 wxPyEndAllowThreads(__tstate);
7782 if (PyErr_Occurred()) SWIG_fail;
7783 }
7784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj;
7793 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7794 PyObject * obj0 = 0 ;
7795 char *kwnames[] = {
7796 (char *) "self", NULL
7797 };
7798
7799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7801 if (SWIG_arg_fail(1)) SWIG_fail;
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 delete arg1;
7805
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 Py_INCREF(Py_None); resultobj = Py_None;
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7819 wxString *arg2 = 0 ;
7820 wxString const &arg3_defvalue = wxPyEmptyString ;
7821 wxString *arg3 = (wxString *) &arg3_defvalue ;
7822 bool result;
7823 bool temp2 = false ;
7824 bool temp3 = false ;
7825 PyObject * obj0 = 0 ;
7826 PyObject * obj1 = 0 ;
7827 PyObject * obj2 = 0 ;
7828 char *kwnames[] = {
7829 (char *) "self",(char *) "name",(char *) "path", NULL
7830 };
7831
7832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7834 if (SWIG_arg_fail(1)) SWIG_fail;
7835 {
7836 arg2 = wxString_in_helper(obj1);
7837 if (arg2 == NULL) SWIG_fail;
7838 temp2 = true;
7839 }
7840 if (obj2) {
7841 {
7842 arg3 = wxString_in_helper(obj2);
7843 if (arg3 == NULL) SWIG_fail;
7844 temp3 = true;
7845 }
7846 }
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 {
7855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7856 }
7857 {
7858 if (temp2)
7859 delete arg2;
7860 }
7861 {
7862 if (temp3)
7863 delete arg3;
7864 }
7865 return resultobj;
7866 fail:
7867 {
7868 if (temp2)
7869 delete arg2;
7870 }
7871 {
7872 if (temp3)
7873 delete arg3;
7874 }
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7882 bool result;
7883 PyObject * obj0 = 0 ;
7884 char *kwnames[] = {
7885 (char *) "self", NULL
7886 };
7887
7888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(1)) SWIG_fail;
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 {
7899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7900 }
7901 return resultobj;
7902 fail:
7903 return NULL;
7904 }
7905
7906
7907 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7908 PyObject *obj;
7909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7910 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7911 Py_INCREF(obj);
7912 return Py_BuildValue((char *)"");
7913 }
7914 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj;
7916 wxWindow *arg1 = (wxWindow *) 0 ;
7917 wxDC *arg2 = 0 ;
7918 bool result;
7919 PyObject * obj0 = 0 ;
7920 PyObject * obj1 = 0 ;
7921 char *kwnames[] = {
7922 (char *) "window",(char *) "dc", NULL
7923 };
7924
7925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7927 if (SWIG_arg_fail(1)) SWIG_fail;
7928 {
7929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7930 if (SWIG_arg_fail(2)) SWIG_fail;
7931 if (arg2 == NULL) {
7932 SWIG_null_ref("wxDC");
7933 }
7934 if (SWIG_arg_fail(2)) SWIG_fail;
7935 }
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 {
7944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7945 }
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7955 PyObject * obj0 = 0 ;
7956 char *kwnames[] = {
7957 (char *) "self", NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7962 if (SWIG_arg_fail(1)) SWIG_fail;
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 delete arg1;
7966
7967 wxPyEndAllowThreads(__tstate);
7968 if (PyErr_Occurred()) SWIG_fail;
7969 }
7970 Py_INCREF(Py_None); resultobj = Py_None;
7971 return resultobj;
7972 fail:
7973 return NULL;
7974 }
7975
7976
7977 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7978 PyObject *resultobj;
7979 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7980 wxString result;
7981 PyObject * obj0 = 0 ;
7982 char *kwnames[] = {
7983 (char *) "self", NULL
7984 };
7985
7986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7988 if (SWIG_arg_fail(1)) SWIG_fail;
7989 {
7990 PyThreadState* __tstate = wxPyBeginAllowThreads();
7991 result = (arg1)->GetTip();
7992
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 {
7997 #if wxUSE_UNICODE
7998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7999 #else
8000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8001 #endif
8002 }
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj;
8011 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8012 size_t result;
8013 PyObject * obj0 = 0 ;
8014 char *kwnames[] = {
8015 (char *) "self", NULL
8016 };
8017
8018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8020 if (SWIG_arg_fail(1)) SWIG_fail;
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (size_t)(arg1)->GetCurrentTip();
8024
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 {
8029 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8030 }
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj;
8039 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8040 wxString *arg2 = 0 ;
8041 wxString result;
8042 bool temp2 = false ;
8043 PyObject * obj0 = 0 ;
8044 PyObject * obj1 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self",(char *) "tip", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 {
8053 arg2 = wxString_in_helper(obj1);
8054 if (arg2 == NULL) SWIG_fail;
8055 temp2 = true;
8056 }
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8060
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 {
8065 #if wxUSE_UNICODE
8066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8067 #else
8068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8069 #endif
8070 }
8071 {
8072 if (temp2)
8073 delete arg2;
8074 }
8075 return resultobj;
8076 fail:
8077 {
8078 if (temp2)
8079 delete arg2;
8080 }
8081 return NULL;
8082 }
8083
8084
8085 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8086 PyObject *obj;
8087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8088 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8089 Py_INCREF(obj);
8090 return Py_BuildValue((char *)"");
8091 }
8092 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8093 PyObject *resultobj;
8094 size_t arg1 ;
8095 wxPyTipProvider *result;
8096 PyObject * obj0 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "currentTip", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8102 {
8103 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 }
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8109
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8123 PyObject *arg2 = (PyObject *) 0 ;
8124 PyObject *arg3 = (PyObject *) 0 ;
8125 PyObject * obj0 = 0 ;
8126 PyObject * obj1 = 0 ;
8127 PyObject * obj2 = 0 ;
8128 char *kwnames[] = {
8129 (char *) "self",(char *) "self",(char *) "_class", NULL
8130 };
8131
8132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8134 if (SWIG_arg_fail(1)) SWIG_fail;
8135 arg2 = obj1;
8136 arg3 = obj2;
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 (arg1)->_setCallbackInfo(arg2,arg3);
8140
8141 wxPyEndAllowThreads(__tstate);
8142 if (PyErr_Occurred()) SWIG_fail;
8143 }
8144 Py_INCREF(Py_None); resultobj = Py_None;
8145 return resultobj;
8146 fail:
8147 return NULL;
8148 }
8149
8150
8151 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8152 PyObject *obj;
8153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8154 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8155 Py_INCREF(obj);
8156 return Py_BuildValue((char *)"");
8157 }
8158 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8159 PyObject *resultobj;
8160 wxWindow *arg1 = (wxWindow *) 0 ;
8161 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8162 bool arg3 = (bool) true ;
8163 bool result;
8164 PyObject * obj0 = 0 ;
8165 PyObject * obj1 = 0 ;
8166 PyObject * obj2 = 0 ;
8167 char *kwnames[] = {
8168 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8169 };
8170
8171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8173 if (SWIG_arg_fail(1)) SWIG_fail;
8174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(2)) SWIG_fail;
8176 if (obj2) {
8177 {
8178 arg3 = (bool)(SWIG_As_bool(obj2));
8179 if (SWIG_arg_fail(3)) SWIG_fail;
8180 }
8181 }
8182 {
8183 if (!wxPyCheckForApp()) SWIG_fail;
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 result = (bool)wxShowTip(arg1,arg2,arg3);
8186
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 {
8191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8192 }
8193 return resultobj;
8194 fail:
8195 return NULL;
8196 }
8197
8198
8199 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj;
8201 wxString *arg1 = 0 ;
8202 size_t arg2 ;
8203 wxTipProvider *result;
8204 bool temp1 = false ;
8205 PyObject * obj0 = 0 ;
8206 PyObject * obj1 = 0 ;
8207 char *kwnames[] = {
8208 (char *) "filename",(char *) "currentTip", NULL
8209 };
8210
8211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8212 {
8213 arg1 = wxString_in_helper(obj0);
8214 if (arg1 == NULL) SWIG_fail;
8215 temp1 = true;
8216 }
8217 {
8218 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8219 if (SWIG_arg_fail(2)) SWIG_fail;
8220 }
8221 {
8222 if (!wxPyCheckForApp()) SWIG_fail;
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8225
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8230 {
8231 if (temp1)
8232 delete arg1;
8233 }
8234 return resultobj;
8235 fail:
8236 {
8237 if (temp1)
8238 delete arg1;
8239 }
8240 return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj;
8246 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8247 int arg2 = (int) -1 ;
8248 wxPyTimer *result;
8249 PyObject * obj0 = 0 ;
8250 PyObject * obj1 = 0 ;
8251 char *kwnames[] = {
8252 (char *) "owner",(char *) "id", NULL
8253 };
8254
8255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8256 if (obj0) {
8257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8258 if (SWIG_arg_fail(1)) SWIG_fail;
8259 }
8260 if (obj1) {
8261 {
8262 arg2 = (int)(SWIG_As_int(obj1));
8263 if (SWIG_arg_fail(2)) SWIG_fail;
8264 }
8265 }
8266 {
8267 if (!wxPyCheckForApp()) SWIG_fail;
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj;
8283 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8284 PyObject * obj0 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 {
8293 PyThreadState* __tstate = wxPyBeginAllowThreads();
8294 delete arg1;
8295
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 Py_INCREF(Py_None); resultobj = Py_None;
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj;
8308 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8309 PyObject *arg2 = (PyObject *) 0 ;
8310 PyObject *arg3 = (PyObject *) 0 ;
8311 int arg4 = (int) 1 ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 PyObject * obj3 = 0 ;
8316 char *kwnames[] = {
8317 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8318 };
8319
8320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8322 if (SWIG_arg_fail(1)) SWIG_fail;
8323 arg2 = obj1;
8324 arg3 = obj2;
8325 if (obj3) {
8326 {
8327 arg4 = (int)(SWIG_As_int(obj3));
8328 if (SWIG_arg_fail(4)) SWIG_fail;
8329 }
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 Py_INCREF(Py_None); resultobj = Py_None;
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj;
8347 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8348 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8349 int arg3 = (int) -1 ;
8350 PyObject * obj0 = 0 ;
8351 PyObject * obj1 = 0 ;
8352 PyObject * obj2 = 0 ;
8353 char *kwnames[] = {
8354 (char *) "self",(char *) "owner",(char *) "id", NULL
8355 };
8356
8357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8359 if (SWIG_arg_fail(1)) SWIG_fail;
8360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8361 if (SWIG_arg_fail(2)) SWIG_fail;
8362 if (obj2) {
8363 {
8364 arg3 = (int)(SWIG_As_int(obj2));
8365 if (SWIG_arg_fail(3)) SWIG_fail;
8366 }
8367 }
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 (arg1)->SetOwner(arg2,arg3);
8371
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 Py_INCREF(Py_None); resultobj = Py_None;
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj;
8384 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8385 wxEvtHandler *result;
8386 PyObject * obj0 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 result = (wxEvtHandler *)(arg1)->GetOwner();
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 {
8402 resultobj = wxPyMake_wxObject(result, 0);
8403 }
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8411 PyObject *resultobj;
8412 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8413 int arg2 = (int) -1 ;
8414 bool arg3 = (bool) false ;
8415 bool result;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 if (obj1) {
8427 {
8428 arg2 = (int)(SWIG_As_int(obj1));
8429 if (SWIG_arg_fail(2)) SWIG_fail;
8430 }
8431 }
8432 if (obj2) {
8433 {
8434 arg3 = (bool)(SWIG_As_bool(obj2));
8435 if (SWIG_arg_fail(3)) SWIG_fail;
8436 }
8437 }
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (bool)(arg1)->Start(arg2,arg3);
8441
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8447 }
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8457 PyObject * obj0 = 0 ;
8458 char *kwnames[] = {
8459 (char *) "self", NULL
8460 };
8461
8462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8464 if (SWIG_arg_fail(1)) SWIG_fail;
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 (arg1)->Stop();
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 Py_INCREF(Py_None); resultobj = Py_None;
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj;
8481 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8482 bool result;
8483 PyObject * obj0 = 0 ;
8484 char *kwnames[] = {
8485 (char *) "self", NULL
8486 };
8487
8488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8490 if (SWIG_arg_fail(1)) SWIG_fail;
8491 {
8492 PyThreadState* __tstate = wxPyBeginAllowThreads();
8493 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8494
8495 wxPyEndAllowThreads(__tstate);
8496 if (PyErr_Occurred()) SWIG_fail;
8497 }
8498 {
8499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8500 }
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8510 int result;
8511 PyObject * obj0 = 0 ;
8512 char *kwnames[] = {
8513 (char *) "self", NULL
8514 };
8515
8516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8518 if (SWIG_arg_fail(1)) SWIG_fail;
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8522
8523 wxPyEndAllowThreads(__tstate);
8524 if (PyErr_Occurred()) SWIG_fail;
8525 }
8526 {
8527 resultobj = SWIG_From_int((int)(result));
8528 }
8529 return resultobj;
8530 fail:
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj;
8537 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8538 bool result;
8539 PyObject * obj0 = 0 ;
8540 char *kwnames[] = {
8541 (char *) "self", NULL
8542 };
8543
8544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8546 if (SWIG_arg_fail(1)) SWIG_fail;
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8550
8551 wxPyEndAllowThreads(__tstate);
8552 if (PyErr_Occurred()) SWIG_fail;
8553 }
8554 {
8555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8556 }
8557 return resultobj;
8558 fail:
8559 return NULL;
8560 }
8561
8562
8563 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj;
8565 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8566 int result;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "self", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (int)((wxPyTimer const *)arg1)->GetId();
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 resultobj = SWIG_From_int((int)(result));
8584 }
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8592 PyObject *obj;
8593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8594 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8595 Py_INCREF(obj);
8596 return Py_BuildValue((char *)"");
8597 }
8598 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 int arg1 = (int) 0 ;
8601 int arg2 = (int) 0 ;
8602 wxTimerEvent *result;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "timerid",(char *) "interval", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8610 if (obj0) {
8611 {
8612 arg1 = (int)(SWIG_As_int(obj0));
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 }
8615 }
8616 if (obj1) {
8617 {
8618 arg2 = (int)(SWIG_As_int(obj1));
8619 if (SWIG_arg_fail(2)) SWIG_fail;
8620 }
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8625
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj;
8638 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8639 int result;
8640 PyObject * obj0 = 0 ;
8641 char *kwnames[] = {
8642 (char *) "self", NULL
8643 };
8644
8645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8651
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 {
8656 resultobj = SWIG_From_int((int)(result));
8657 }
8658 return resultobj;
8659 fail:
8660 return NULL;
8661 }
8662
8663
8664 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8665 PyObject *obj;
8666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8667 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8668 Py_INCREF(obj);
8669 return Py_BuildValue((char *)"");
8670 }
8671 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8672 PyObject *resultobj;
8673 wxTimer *arg1 = 0 ;
8674 wxTimerRunner *result;
8675 PyObject * obj0 = 0 ;
8676
8677 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8678 {
8679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8680 if (SWIG_arg_fail(1)) SWIG_fail;
8681 if (arg1 == NULL) {
8682 SWIG_null_ref("wxTimer");
8683 }
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 }
8686 {
8687 if (!wxPyCheckForApp()) SWIG_fail;
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8690
8691 wxPyEndAllowThreads(__tstate);
8692 if (PyErr_Occurred()) SWIG_fail;
8693 }
8694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8695 return resultobj;
8696 fail:
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8702 PyObject *resultobj;
8703 wxTimer *arg1 = 0 ;
8704 int arg2 ;
8705 bool arg3 = (bool) false ;
8706 wxTimerRunner *result;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 PyObject * obj2 = 0 ;
8710
8711 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8712 {
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 if (arg1 == NULL) {
8716 SWIG_null_ref("wxTimer");
8717 }
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 }
8720 {
8721 arg2 = (int)(SWIG_As_int(obj1));
8722 if (SWIG_arg_fail(2)) SWIG_fail;
8723 }
8724 if (obj2) {
8725 {
8726 arg3 = (bool)(SWIG_As_bool(obj2));
8727 if (SWIG_arg_fail(3)) SWIG_fail;
8728 }
8729 }
8730 {
8731 if (!wxPyCheckForApp()) SWIG_fail;
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8734
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8746 int argc;
8747 PyObject *argv[4];
8748 int ii;
8749
8750 argc = PyObject_Length(args);
8751 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8752 argv[ii] = PyTuple_GetItem(args,ii);
8753 }
8754 if (argc == 1) {
8755 int _v;
8756 {
8757 void *ptr = 0;
8758 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8759 _v = 0;
8760 PyErr_Clear();
8761 } else {
8762 _v = (ptr != 0);
8763 }
8764 }
8765 if (_v) {
8766 return _wrap_new_TimerRunner__SWIG_0(self,args);
8767 }
8768 }
8769 if ((argc >= 2) && (argc <= 3)) {
8770 int _v;
8771 {
8772 void *ptr = 0;
8773 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8774 _v = 0;
8775 PyErr_Clear();
8776 } else {
8777 _v = (ptr != 0);
8778 }
8779 }
8780 if (_v) {
8781 _v = SWIG_Check_int(argv[1]);
8782 if (_v) {
8783 if (argc <= 2) {
8784 return _wrap_new_TimerRunner__SWIG_1(self,args);
8785 }
8786 _v = SWIG_Check_bool(argv[2]);
8787 if (_v) {
8788 return _wrap_new_TimerRunner__SWIG_1(self,args);
8789 }
8790 }
8791 }
8792 }
8793
8794 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8795 return NULL;
8796 }
8797
8798
8799 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj;
8801 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8802 PyObject * obj0 = 0 ;
8803 char *kwnames[] = {
8804 (char *) "self", NULL
8805 };
8806
8807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8809 if (SWIG_arg_fail(1)) SWIG_fail;
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 delete arg1;
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 Py_INCREF(Py_None); resultobj = Py_None;
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj;
8826 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8827 int arg2 ;
8828 bool arg3 = (bool) false ;
8829 PyObject * obj0 = 0 ;
8830 PyObject * obj1 = 0 ;
8831 PyObject * obj2 = 0 ;
8832 char *kwnames[] = {
8833 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(1)) SWIG_fail;
8839 {
8840 arg2 = (int)(SWIG_As_int(obj1));
8841 if (SWIG_arg_fail(2)) SWIG_fail;
8842 }
8843 if (obj2) {
8844 {
8845 arg3 = (bool)(SWIG_As_bool(obj2));
8846 if (SWIG_arg_fail(3)) SWIG_fail;
8847 }
8848 }
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 (arg1)->Start(arg2,arg3);
8852
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 Py_INCREF(Py_None); resultobj = Py_None;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8864 PyObject *obj;
8865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8866 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8867 Py_INCREF(obj);
8868 return Py_BuildValue((char *)"");
8869 }
8870 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8871 PyObject *resultobj;
8872 wxLog *result;
8873 char *kwnames[] = {
8874 NULL
8875 };
8876
8877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 result = (wxLog *)new wxLog();
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj;
8894 bool result;
8895 char *kwnames[] = {
8896 NULL
8897 };
8898
8899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (bool)wxLog::IsEnabled();
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8909 }
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj;
8918 bool arg1 = (bool) true ;
8919 bool result;
8920 PyObject * obj0 = 0 ;
8921 char *kwnames[] = {
8922 (char *) "doIt", NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8926 if (obj0) {
8927 {
8928 arg1 = (bool)(SWIG_As_bool(obj0));
8929 if (SWIG_arg_fail(1)) SWIG_fail;
8930 }
8931 }
8932 {
8933 PyThreadState* __tstate = wxPyBeginAllowThreads();
8934 result = (bool)wxLog::EnableLogging(arg1);
8935
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 {
8940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8941 }
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8949 PyObject *resultobj;
8950 wxLogLevel arg1 ;
8951 wxChar *arg2 = (wxChar *) 0 ;
8952 time_t arg3 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 PyObject * obj2 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "level",(char *) "szString",(char *) "t", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8961 {
8962 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 }
8965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(2)) SWIG_fail;
8967 {
8968 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8969 if (SWIG_arg_fail(3)) SWIG_fail;
8970 }
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8974
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 Py_INCREF(Py_None); resultobj = Py_None;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj;
8987 wxLog *arg1 = (wxLog *) 0 ;
8988 PyObject * obj0 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "self", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(1)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 (arg1)->Flush();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 Py_INCREF(Py_None); resultobj = Py_None;
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9011 PyObject *resultobj;
9012 char *kwnames[] = {
9013 NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxLog::FlushActive();
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 wxLog *result;
9034 char *kwnames[] = {
9035 NULL
9036 };
9037
9038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 result = (wxLog *)wxLog::GetActiveTarget();
9042
9043 wxPyEndAllowThreads(__tstate);
9044 if (PyErr_Occurred()) SWIG_fail;
9045 }
9046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9047 return resultobj;
9048 fail:
9049 return NULL;
9050 }
9051
9052
9053 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj;
9055 wxLog *arg1 = (wxLog *) 0 ;
9056 wxLog *result;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "pLogger", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9064 if (SWIG_arg_fail(1)) SWIG_fail;
9065 {
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9068
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj;
9081 char *kwnames[] = {
9082 NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 wxLog::Suspend();
9089
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 Py_INCREF(Py_None); resultobj = Py_None;
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj;
9102 char *kwnames[] = {
9103 NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 wxLog::Resume();
9110
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 Py_INCREF(Py_None); resultobj = Py_None;
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9122 PyObject *resultobj;
9123 bool arg1 = (bool) true ;
9124 PyObject * obj0 = 0 ;
9125 char *kwnames[] = {
9126 (char *) "bVerbose", NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9130 if (obj0) {
9131 {
9132 arg1 = (bool)(SWIG_As_bool(obj0));
9133 if (SWIG_arg_fail(1)) SWIG_fail;
9134 }
9135 }
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 wxLog::SetVerbose(arg1);
9139
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 Py_INCREF(Py_None); resultobj = Py_None;
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj;
9152 wxLogLevel arg1 ;
9153 PyObject * obj0 = 0 ;
9154 char *kwnames[] = {
9155 (char *) "logLevel", NULL
9156 };
9157
9158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9159 {
9160 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9161 if (SWIG_arg_fail(1)) SWIG_fail;
9162 }
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 wxLog::SetLogLevel(arg1);
9166
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 Py_INCREF(Py_None); resultobj = Py_None;
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj;
9179 char *kwnames[] = {
9180 NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 wxLog::DontCreateOnDemand();
9187
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 Py_INCREF(Py_None); resultobj = Py_None;
9192 return resultobj;
9193 fail:
9194 return NULL;
9195 }
9196
9197
9198 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9199 PyObject *resultobj;
9200 wxTraceMask arg1 ;
9201 PyObject * obj0 = 0 ;
9202 char *kwnames[] = {
9203 (char *) "ulMask", NULL
9204 };
9205
9206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9207 {
9208 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9209 if (SWIG_arg_fail(1)) SWIG_fail;
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 wxLog::SetTraceMask(arg1);
9214
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 Py_INCREF(Py_None); resultobj = Py_None;
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj;
9227 wxString *arg1 = 0 ;
9228 bool temp1 = false ;
9229 PyObject * obj0 = 0 ;
9230 char *kwnames[] = {
9231 (char *) "str", NULL
9232 };
9233
9234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9235 {
9236 arg1 = wxString_in_helper(obj0);
9237 if (arg1 == NULL) SWIG_fail;
9238 temp1 = true;
9239 }
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 wxLog::AddTraceMask((wxString const &)*arg1);
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 Py_INCREF(Py_None); resultobj = Py_None;
9248 {
9249 if (temp1)
9250 delete arg1;
9251 }
9252 return resultobj;
9253 fail:
9254 {
9255 if (temp1)
9256 delete arg1;
9257 }
9258 return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9263 PyObject *resultobj;
9264 wxString *arg1 = 0 ;
9265 bool temp1 = false ;
9266 PyObject * obj0 = 0 ;
9267 char *kwnames[] = {
9268 (char *) "str", NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9272 {
9273 arg1 = wxString_in_helper(obj0);
9274 if (arg1 == NULL) SWIG_fail;
9275 temp1 = true;
9276 }
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 wxLog::RemoveTraceMask((wxString const &)*arg1);
9280
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 Py_INCREF(Py_None); resultobj = Py_None;
9285 {
9286 if (temp1)
9287 delete arg1;
9288 }
9289 return resultobj;
9290 fail:
9291 {
9292 if (temp1)
9293 delete arg1;
9294 }
9295 return NULL;
9296 }
9297
9298
9299 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9300 PyObject *resultobj;
9301 char *kwnames[] = {
9302 NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 wxLog::ClearTraceMasks();
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 Py_INCREF(Py_None); resultobj = Py_None;
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj;
9322 wxArrayString *result;
9323 char *kwnames[] = {
9324 NULL
9325 };
9326
9327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9328 {
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 {
9331 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9332 result = (wxArrayString *) &_result_ref;
9333 }
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 {
9339 resultobj = wxArrayString2PyList_helper(*result);
9340 }
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxChar *arg1 = (wxChar *) 0 ;
9350 PyObject * obj0 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "ts", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 wxLog::SetTimestamp((wxChar const *)arg1);
9361
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 Py_INCREF(Py_None); resultobj = Py_None;
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj;
9374 bool result;
9375 char *kwnames[] = {
9376 NULL
9377 };
9378
9379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (bool)wxLog::GetVerbose();
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj;
9398 wxTraceMask result;
9399 char *kwnames[] = {
9400 NULL
9401 };
9402
9403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (wxTraceMask)wxLog::GetTraceMask();
9407
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 {
9412 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9413 }
9414 return resultobj;
9415 fail:
9416 return NULL;
9417 }
9418
9419
9420 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9421 PyObject *resultobj;
9422 wxChar *arg1 = (wxChar *) 0 ;
9423 bool result;
9424 PyObject * obj0 = 0 ;
9425 char *kwnames[] = {
9426 (char *) "mask", NULL
9427 };
9428
9429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9431 if (SWIG_arg_fail(1)) SWIG_fail;
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9441 }
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj;
9450 wxLogLevel result;
9451 char *kwnames[] = {
9452 NULL
9453 };
9454
9455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (wxLogLevel)wxLog::GetLogLevel();
9459
9460 wxPyEndAllowThreads(__tstate);
9461 if (PyErr_Occurred()) SWIG_fail;
9462 }
9463 {
9464 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9465 }
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj;
9474 wxChar *result;
9475 char *kwnames[] = {
9476 NULL
9477 };
9478
9479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (wxChar *)wxLog::GetTimestamp();
9483
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj;
9496 wxString result;
9497 char *kwnames[] = {
9498 NULL
9499 };
9500
9501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = Log_TimeStamp();
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 {
9510 #if wxUSE_UNICODE
9511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9512 #else
9513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9514 #endif
9515 }
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9523 PyObject *resultobj;
9524 wxLog *arg1 = (wxLog *) 0 ;
9525 PyObject * obj0 = 0 ;
9526 char *kwnames[] = {
9527 (char *) "self", NULL
9528 };
9529
9530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9532 if (SWIG_arg_fail(1)) SWIG_fail;
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 wxLog_Destroy(arg1);
9536
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 Py_INCREF(Py_None); resultobj = Py_None;
9541 return resultobj;
9542 fail:
9543 return NULL;
9544 }
9545
9546
9547 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9548 PyObject *obj;
9549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9550 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9551 Py_INCREF(obj);
9552 return Py_BuildValue((char *)"");
9553 }
9554 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj;
9556 wxLogStderr *result;
9557 char *kwnames[] = {
9558 NULL
9559 };
9560
9561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 result = (wxLogStderr *)new wxLogStderr();
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9570 return resultobj;
9571 fail:
9572 return NULL;
9573 }
9574
9575
9576 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9577 PyObject *obj;
9578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9579 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9580 Py_INCREF(obj);
9581 return Py_BuildValue((char *)"");
9582 }
9583 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9586 wxLogTextCtrl *result;
9587 PyObject * obj0 = 0 ;
9588 char *kwnames[] = {
9589 (char *) "pTextCtrl", NULL
9590 };
9591
9592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9594 if (SWIG_arg_fail(1)) SWIG_fail;
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9598
9599 wxPyEndAllowThreads(__tstate);
9600 if (PyErr_Occurred()) SWIG_fail;
9601 }
9602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9603 return resultobj;
9604 fail:
9605 return NULL;
9606 }
9607
9608
9609 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9610 PyObject *obj;
9611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9612 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9613 Py_INCREF(obj);
9614 return Py_BuildValue((char *)"");
9615 }
9616 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxLogGui *result;
9619 char *kwnames[] = {
9620 NULL
9621 };
9622
9623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 result = (wxLogGui *)new wxLogGui();
9627
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9639 PyObject *obj;
9640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9641 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9642 Py_INCREF(obj);
9643 return Py_BuildValue((char *)"");
9644 }
9645 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxFrame *arg1 = (wxFrame *) 0 ;
9648 wxString *arg2 = 0 ;
9649 bool arg3 = (bool) true ;
9650 bool arg4 = (bool) true ;
9651 wxLogWindow *result;
9652 bool temp2 = false ;
9653 PyObject * obj0 = 0 ;
9654 PyObject * obj1 = 0 ;
9655 PyObject * obj2 = 0 ;
9656 PyObject * obj3 = 0 ;
9657 char *kwnames[] = {
9658 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9659 };
9660
9661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9663 if (SWIG_arg_fail(1)) SWIG_fail;
9664 {
9665 arg2 = wxString_in_helper(obj1);
9666 if (arg2 == NULL) SWIG_fail;
9667 temp2 = true;
9668 }
9669 if (obj2) {
9670 {
9671 arg3 = (bool)(SWIG_As_bool(obj2));
9672 if (SWIG_arg_fail(3)) SWIG_fail;
9673 }
9674 }
9675 if (obj3) {
9676 {
9677 arg4 = (bool)(SWIG_As_bool(obj3));
9678 if (SWIG_arg_fail(4)) SWIG_fail;
9679 }
9680 }
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9689 {
9690 if (temp2)
9691 delete arg2;
9692 }
9693 return resultobj;
9694 fail:
9695 {
9696 if (temp2)
9697 delete arg2;
9698 }
9699 return NULL;
9700 }
9701
9702
9703 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj;
9705 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9706 bool arg2 = (bool) true ;
9707 PyObject * obj0 = 0 ;
9708 PyObject * obj1 = 0 ;
9709 char *kwnames[] = {
9710 (char *) "self",(char *) "bShow", NULL
9711 };
9712
9713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9715 if (SWIG_arg_fail(1)) SWIG_fail;
9716 if (obj1) {
9717 {
9718 arg2 = (bool)(SWIG_As_bool(obj1));
9719 if (SWIG_arg_fail(2)) SWIG_fail;
9720 }
9721 }
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->Show(arg2);
9725
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 Py_INCREF(Py_None); resultobj = Py_None;
9730 return resultobj;
9731 fail:
9732 return NULL;
9733 }
9734
9735
9736 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj;
9738 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9739 wxFrame *result;
9740 PyObject * obj0 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 PyThreadState* __tstate = wxPyBeginAllowThreads();
9750 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9751
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 {
9756 resultobj = wxPyMake_wxObject(result, 0);
9757 }
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9765 PyObject *resultobj;
9766 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9767 wxLog *result;
9768 PyObject * obj0 = 0 ;
9769 char *kwnames[] = {
9770 (char *) "self", NULL
9771 };
9772
9773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9775 if (SWIG_arg_fail(1)) SWIG_fail;
9776 {
9777 PyThreadState* __tstate = wxPyBeginAllowThreads();
9778 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9779
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9784 return resultobj;
9785 fail:
9786 return NULL;
9787 }
9788
9789
9790 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj;
9792 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9793 bool result;
9794 PyObject * obj0 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "self", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9801 if (SWIG_arg_fail(1)) SWIG_fail;
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9805
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 {
9810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9811 }
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj;
9820 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9821 bool arg2 ;
9822 PyObject * obj0 = 0 ;
9823 PyObject * obj1 = 0 ;
9824 char *kwnames[] = {
9825 (char *) "self",(char *) "bDoPass", NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9830 if (SWIG_arg_fail(1)) SWIG_fail;
9831 {
9832 arg2 = (bool)(SWIG_As_bool(obj1));
9833 if (SWIG_arg_fail(2)) SWIG_fail;
9834 }
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 (arg1)->PassMessages(arg2);
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 Py_INCREF(Py_None); resultobj = Py_None;
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9850 PyObject *obj;
9851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9852 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9853 Py_INCREF(obj);
9854 return Py_BuildValue((char *)"");
9855 }
9856 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxLog *arg1 = (wxLog *) 0 ;
9859 wxLogChain *result;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "logger", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9867 if (SWIG_arg_fail(1)) SWIG_fail;
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (wxLogChain *)new wxLogChain(arg1);
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj;
9884 wxLogChain *arg1 = (wxLogChain *) 0 ;
9885 wxLog *arg2 = (wxLog *) 0 ;
9886 PyObject * obj0 = 0 ;
9887 PyObject * obj1 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self",(char *) "logger", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9896 if (SWIG_arg_fail(2)) SWIG_fail;
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 (arg1)->SetLog(arg2);
9900
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 Py_INCREF(Py_None); resultobj = Py_None;
9905 return resultobj;
9906 fail:
9907 return NULL;
9908 }
9909
9910
9911 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9912 PyObject *resultobj;
9913 wxLogChain *arg1 = (wxLogChain *) 0 ;
9914 bool arg2 ;
9915 PyObject * obj0 = 0 ;
9916 PyObject * obj1 = 0 ;
9917 char *kwnames[] = {
9918 (char *) "self",(char *) "bDoPass", NULL
9919 };
9920
9921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9923 if (SWIG_arg_fail(1)) SWIG_fail;
9924 {
9925 arg2 = (bool)(SWIG_As_bool(obj1));
9926 if (SWIG_arg_fail(2)) SWIG_fail;
9927 }
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 (arg1)->PassMessages(arg2);
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 Py_INCREF(Py_None); resultobj = Py_None;
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj;
9944 wxLogChain *arg1 = (wxLogChain *) 0 ;
9945 bool result;
9946 PyObject * obj0 = 0 ;
9947 char *kwnames[] = {
9948 (char *) "self", NULL
9949 };
9950
9951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (bool)(arg1)->IsPassingMessages();
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 {
9962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9963 }
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj;
9972 wxLogChain *arg1 = (wxLogChain *) 0 ;
9973 wxLog *result;
9974 PyObject * obj0 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "self", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9981 if (SWIG_arg_fail(1)) SWIG_fail;
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 result = (wxLog *)(arg1)->GetOldLog();
9985
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9997 PyObject *obj;
9998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9999 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10000 Py_INCREF(obj);
10001 return Py_BuildValue((char *)"");
10002 }
10003 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 unsigned long result;
10006 char *kwnames[] = {
10007 NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 result = (unsigned long)wxSysErrorCode();
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 {
10019 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10020 }
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj;
10029 unsigned long arg1 = (unsigned long) 0 ;
10030 wxString result;
10031 PyObject * obj0 = 0 ;
10032 char *kwnames[] = {
10033 (char *) "nErrCode", NULL
10034 };
10035
10036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10037 if (obj0) {
10038 {
10039 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10040 if (SWIG_arg_fail(1)) SWIG_fail;
10041 }
10042 }
10043 {
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 result = wxSysErrorMsg(arg1);
10046
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 {
10051 #if wxUSE_UNICODE
10052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10053 #else
10054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10055 #endif
10056 }
10057 return resultobj;
10058 fail:
10059 return NULL;
10060 }
10061
10062
10063 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10064 PyObject *resultobj;
10065 wxString *arg1 = 0 ;
10066 bool temp1 = false ;
10067 PyObject * obj0 = 0 ;
10068 char *kwnames[] = {
10069 (char *) "msg", NULL
10070 };
10071
10072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10073 {
10074 arg1 = wxString_in_helper(obj0);
10075 if (arg1 == NULL) SWIG_fail;
10076 temp1 = true;
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 wxPyLogFatalError((wxString const &)*arg1);
10081
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 Py_INCREF(Py_None); resultobj = Py_None;
10086 {
10087 if (temp1)
10088 delete arg1;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp1)
10094 delete arg1;
10095 }
10096 return NULL;
10097 }
10098
10099
10100 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj;
10102 wxString *arg1 = 0 ;
10103 bool temp1 = false ;
10104 PyObject * obj0 = 0 ;
10105 char *kwnames[] = {
10106 (char *) "msg", NULL
10107 };
10108
10109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10110 {
10111 arg1 = wxString_in_helper(obj0);
10112 if (arg1 == NULL) SWIG_fail;
10113 temp1 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 wxPyLogError((wxString const &)*arg1);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp1)
10125 delete arg1;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp1)
10131 delete arg1;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxString *arg1 = 0 ;
10140 bool temp1 = false ;
10141 PyObject * obj0 = 0 ;
10142 char *kwnames[] = {
10143 (char *) "msg", NULL
10144 };
10145
10146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10147 {
10148 arg1 = wxString_in_helper(obj0);
10149 if (arg1 == NULL) SWIG_fail;
10150 temp1 = true;
10151 }
10152 {
10153 PyThreadState* __tstate = wxPyBeginAllowThreads();
10154 wxPyLogWarning((wxString const &)*arg1);
10155
10156 wxPyEndAllowThreads(__tstate);
10157 if (PyErr_Occurred()) SWIG_fail;
10158 }
10159 Py_INCREF(Py_None); resultobj = Py_None;
10160 {
10161 if (temp1)
10162 delete arg1;
10163 }
10164 return resultobj;
10165 fail:
10166 {
10167 if (temp1)
10168 delete arg1;
10169 }
10170 return NULL;
10171 }
10172
10173
10174 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj;
10176 wxString *arg1 = 0 ;
10177 bool temp1 = false ;
10178 PyObject * obj0 = 0 ;
10179 char *kwnames[] = {
10180 (char *) "msg", NULL
10181 };
10182
10183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10184 {
10185 arg1 = wxString_in_helper(obj0);
10186 if (arg1 == NULL) SWIG_fail;
10187 temp1 = true;
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 wxPyLogMessage((wxString const &)*arg1);
10192
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 Py_INCREF(Py_None); resultobj = Py_None;
10197 {
10198 if (temp1)
10199 delete arg1;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp1)
10205 delete arg1;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj;
10213 wxString *arg1 = 0 ;
10214 bool temp1 = false ;
10215 PyObject * obj0 = 0 ;
10216 char *kwnames[] = {
10217 (char *) "msg", NULL
10218 };
10219
10220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10221 {
10222 arg1 = wxString_in_helper(obj0);
10223 if (arg1 == NULL) SWIG_fail;
10224 temp1 = true;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 wxPyLogInfo((wxString const &)*arg1);
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 Py_INCREF(Py_None); resultobj = Py_None;
10234 {
10235 if (temp1)
10236 delete arg1;
10237 }
10238 return resultobj;
10239 fail:
10240 {
10241 if (temp1)
10242 delete arg1;
10243 }
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 wxString *arg1 = 0 ;
10251 bool temp1 = false ;
10252 PyObject * obj0 = 0 ;
10253 char *kwnames[] = {
10254 (char *) "msg", NULL
10255 };
10256
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10258 {
10259 arg1 = wxString_in_helper(obj0);
10260 if (arg1 == NULL) SWIG_fail;
10261 temp1 = true;
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 wxPyLogDebug((wxString const &)*arg1);
10266
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 Py_INCREF(Py_None); resultobj = Py_None;
10271 {
10272 if (temp1)
10273 delete arg1;
10274 }
10275 return resultobj;
10276 fail:
10277 {
10278 if (temp1)
10279 delete arg1;
10280 }
10281 return NULL;
10282 }
10283
10284
10285 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj;
10287 wxString *arg1 = 0 ;
10288 bool temp1 = false ;
10289 PyObject * obj0 = 0 ;
10290 char *kwnames[] = {
10291 (char *) "msg", NULL
10292 };
10293
10294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10295 {
10296 arg1 = wxString_in_helper(obj0);
10297 if (arg1 == NULL) SWIG_fail;
10298 temp1 = true;
10299 }
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 wxPyLogVerbose((wxString const &)*arg1);
10303
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 Py_INCREF(Py_None); resultobj = Py_None;
10308 {
10309 if (temp1)
10310 delete arg1;
10311 }
10312 return resultobj;
10313 fail:
10314 {
10315 if (temp1)
10316 delete arg1;
10317 }
10318 return NULL;
10319 }
10320
10321
10322 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj;
10324 wxString *arg1 = 0 ;
10325 bool temp1 = false ;
10326 PyObject * obj0 = 0 ;
10327 char *kwnames[] = {
10328 (char *) "msg", NULL
10329 };
10330
10331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10332 {
10333 arg1 = wxString_in_helper(obj0);
10334 if (arg1 == NULL) SWIG_fail;
10335 temp1 = true;
10336 }
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 wxPyLogStatus((wxString const &)*arg1);
10340
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 Py_INCREF(Py_None); resultobj = Py_None;
10345 {
10346 if (temp1)
10347 delete arg1;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp1)
10353 delete arg1;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj;
10361 wxFrame *arg1 = (wxFrame *) 0 ;
10362 wxString *arg2 = 0 ;
10363 bool temp2 = false ;
10364 PyObject * obj0 = 0 ;
10365 PyObject * obj1 = 0 ;
10366 char *kwnames[] = {
10367 (char *) "pFrame",(char *) "msg", NULL
10368 };
10369
10370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10372 if (SWIG_arg_fail(1)) SWIG_fail;
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 Py_INCREF(Py_None); resultobj = Py_None;
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return resultobj;
10391 fail:
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return NULL;
10397 }
10398
10399
10400 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj;
10402 wxString *arg1 = 0 ;
10403 bool temp1 = false ;
10404 PyObject * obj0 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "msg", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10410 {
10411 arg1 = wxString_in_helper(obj0);
10412 if (arg1 == NULL) SWIG_fail;
10413 temp1 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 wxPyLogSysError((wxString const &)*arg1);
10418
10419 wxPyEndAllowThreads(__tstate);
10420 if (PyErr_Occurred()) SWIG_fail;
10421 }
10422 Py_INCREF(Py_None); resultobj = Py_None;
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 return resultobj;
10428 fail:
10429 {
10430 if (temp1)
10431 delete arg1;
10432 }
10433 return NULL;
10434 }
10435
10436
10437 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10438 PyObject *resultobj;
10439 unsigned long arg1 ;
10440 wxString *arg2 = 0 ;
10441 bool temp2 = false ;
10442 PyObject * obj0 = 0 ;
10443 PyObject * obj1 = 0 ;
10444 char *kwnames[] = {
10445 (char *) "level",(char *) "msg", NULL
10446 };
10447
10448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10449 {
10450 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10451 if (SWIG_arg_fail(1)) SWIG_fail;
10452 }
10453 {
10454 arg2 = wxString_in_helper(obj1);
10455 if (arg2 == NULL) SWIG_fail;
10456 temp2 = true;
10457 }
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10461
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 Py_INCREF(Py_None); resultobj = Py_None;
10466 {
10467 if (temp2)
10468 delete arg2;
10469 }
10470 return resultobj;
10471 fail:
10472 {
10473 if (temp2)
10474 delete arg2;
10475 }
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10481 PyObject *resultobj;
10482 unsigned long arg1 ;
10483 wxString *arg2 = 0 ;
10484 bool temp2 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487
10488 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10489 {
10490 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10491 if (SWIG_arg_fail(1)) SWIG_fail;
10492 }
10493 {
10494 arg2 = wxString_in_helper(obj1);
10495 if (arg2 == NULL) SWIG_fail;
10496 temp2 = true;
10497 }
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 wxPyLogTrace(arg1,(wxString const &)*arg2);
10501
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 Py_INCREF(Py_None); resultobj = Py_None;
10506 {
10507 if (temp2)
10508 delete arg2;
10509 }
10510 return resultobj;
10511 fail:
10512 {
10513 if (temp2)
10514 delete arg2;
10515 }
10516 return NULL;
10517 }
10518
10519
10520 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10521 PyObject *resultobj;
10522 wxString *arg1 = 0 ;
10523 wxString *arg2 = 0 ;
10524 bool temp1 = false ;
10525 bool temp2 = false ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528
10529 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10530 {
10531 arg1 = wxString_in_helper(obj0);
10532 if (arg1 == NULL) SWIG_fail;
10533 temp1 = true;
10534 }
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 Py_INCREF(Py_None); resultobj = Py_None;
10548 {
10549 if (temp1)
10550 delete arg1;
10551 }
10552 {
10553 if (temp2)
10554 delete arg2;
10555 }
10556 return resultobj;
10557 fail:
10558 {
10559 if (temp1)
10560 delete arg1;
10561 }
10562 {
10563 if (temp2)
10564 delete arg2;
10565 }
10566 return NULL;
10567 }
10568
10569
10570 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10571 int argc;
10572 PyObject *argv[3];
10573 int ii;
10574
10575 argc = PyObject_Length(args);
10576 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10577 argv[ii] = PyTuple_GetItem(args,ii);
10578 }
10579 if (argc == 2) {
10580 int _v;
10581 {
10582 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10583 }
10584 if (_v) {
10585 {
10586 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10587 }
10588 if (_v) {
10589 return _wrap_LogTrace__SWIG_1(self,args);
10590 }
10591 }
10592 }
10593 if (argc == 2) {
10594 int _v;
10595 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10596 if (_v) {
10597 {
10598 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10599 }
10600 if (_v) {
10601 return _wrap_LogTrace__SWIG_0(self,args);
10602 }
10603 }
10604 }
10605
10606 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10607 return NULL;
10608 }
10609
10610
10611 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj;
10613 wxString *arg1 = 0 ;
10614 wxString *arg2 = 0 ;
10615 bool temp1 = false ;
10616 bool temp2 = false ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 char *kwnames[] = {
10620 (char *) "title",(char *) "text", NULL
10621 };
10622
10623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10624 {
10625 arg1 = wxString_in_helper(obj0);
10626 if (arg1 == NULL) SWIG_fail;
10627 temp1 = true;
10628 }
10629 {
10630 arg2 = wxString_in_helper(obj1);
10631 if (arg2 == NULL) SWIG_fail;
10632 temp2 = true;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 Py_INCREF(Py_None); resultobj = Py_None;
10642 {
10643 if (temp1)
10644 delete arg1;
10645 }
10646 {
10647 if (temp2)
10648 delete arg2;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (temp1)
10654 delete arg1;
10655 }
10656 {
10657 if (temp2)
10658 delete arg2;
10659 }
10660 return NULL;
10661 }
10662
10663
10664 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj;
10666 wxLogNull *result;
10667 char *kwnames[] = {
10668 NULL
10669 };
10670
10671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = (wxLogNull *)new wxLogNull();
10675
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10680 return resultobj;
10681 fail:
10682 return NULL;
10683 }
10684
10685
10686 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj;
10688 wxLogNull *arg1 = (wxLogNull *) 0 ;
10689 PyObject * obj0 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 delete arg1;
10700
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 Py_INCREF(Py_None); resultobj = Py_None;
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10712 PyObject *obj;
10713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10714 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10715 Py_INCREF(obj);
10716 return Py_BuildValue((char *)"");
10717 }
10718 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj;
10720 wxPyLog *result;
10721 char *kwnames[] = {
10722 NULL
10723 };
10724
10725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (wxPyLog *)new wxPyLog();
10729
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj;
10742 wxPyLog *arg1 = (wxPyLog *) 0 ;
10743 PyObject *arg2 = (PyObject *) 0 ;
10744 PyObject *arg3 = (PyObject *) 0 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 PyObject * obj2 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self",(char *) "self",(char *) "_class", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 arg2 = obj1;
10756 arg3 = obj2;
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->_setCallbackInfo(arg2,arg3);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10772 PyObject *obj;
10773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10774 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10775 Py_INCREF(obj);
10776 return Py_BuildValue((char *)"");
10777 }
10778 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj;
10780 int arg1 ;
10781 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10782 int arg3 = (int) wxKILL_NOCHILDREN ;
10783 wxKillError result;
10784 PyObject * obj0 = 0 ;
10785 PyObject * obj1 = 0 ;
10786 PyObject * obj2 = 0 ;
10787 char *kwnames[] = {
10788 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10789 };
10790
10791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10792 {
10793 arg1 = (int)(SWIG_As_int(obj0));
10794 if (SWIG_arg_fail(1)) SWIG_fail;
10795 }
10796 if (obj1) {
10797 {
10798 arg2 = (wxSignal)(SWIG_As_int(obj1));
10799 if (SWIG_arg_fail(2)) SWIG_fail;
10800 }
10801 }
10802 if (obj2) {
10803 {
10804 arg3 = (int)(SWIG_As_int(obj2));
10805 if (SWIG_arg_fail(3)) SWIG_fail;
10806 }
10807 }
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10811
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 resultobj = SWIG_From_int((result));
10816 return resultobj;
10817 fail:
10818 return NULL;
10819 }
10820
10821
10822 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10823 PyObject *resultobj;
10824 int arg1 ;
10825 bool result;
10826 PyObject * obj0 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "pid", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10832 {
10833 arg1 = (int)(SWIG_As_int(obj0));
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (bool)wxPyProcess::Exists(arg1);
10839
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 {
10844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10845 }
10846 return resultobj;
10847 fail:
10848 return NULL;
10849 }
10850
10851
10852 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10853 PyObject *resultobj;
10854 wxString *arg1 = 0 ;
10855 int arg2 = (int) wxEXEC_ASYNC ;
10856 wxPyProcess *result;
10857 bool temp1 = false ;
10858 PyObject * obj0 = 0 ;
10859 PyObject * obj1 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "cmd",(char *) "flags", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10865 {
10866 arg1 = wxString_in_helper(obj0);
10867 if (arg1 == NULL) SWIG_fail;
10868 temp1 = true;
10869 }
10870 if (obj1) {
10871 {
10872 arg2 = (int)(SWIG_As_int(obj1));
10873 if (SWIG_arg_fail(2)) SWIG_fail;
10874 }
10875 }
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10884 {
10885 if (temp1)
10886 delete arg1;
10887 }
10888 return resultobj;
10889 fail:
10890 {
10891 if (temp1)
10892 delete arg1;
10893 }
10894 return NULL;
10895 }
10896
10897
10898 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10899 PyObject *resultobj;
10900 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10901 int arg2 = (int) -1 ;
10902 wxPyProcess *result;
10903 PyObject * obj0 = 0 ;
10904 PyObject * obj1 = 0 ;
10905 char *kwnames[] = {
10906 (char *) "parent",(char *) "id", NULL
10907 };
10908
10909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10910 if (obj0) {
10911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10912 if (SWIG_arg_fail(1)) SWIG_fail;
10913 }
10914 if (obj1) {
10915 {
10916 arg2 = (int)(SWIG_As_int(obj1));
10917 if (SWIG_arg_fail(2)) SWIG_fail;
10918 }
10919 }
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10923
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj;
10936 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10937 PyObject *arg2 = (PyObject *) 0 ;
10938 PyObject *arg3 = (PyObject *) 0 ;
10939 PyObject * obj0 = 0 ;
10940 PyObject * obj1 = 0 ;
10941 PyObject * obj2 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self",(char *) "self",(char *) "_class", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 arg2 = obj1;
10950 arg3 = obj2;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 (arg1)->_setCallbackInfo(arg2,arg3);
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 Py_INCREF(Py_None); resultobj = Py_None;
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10968 int arg2 ;
10969 int arg3 ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 PyObject * obj2 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self",(char *) "pid",(char *) "status", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 arg2 = (int)(SWIG_As_int(obj1));
10982 if (SWIG_arg_fail(2)) SWIG_fail;
10983 }
10984 {
10985 arg3 = (int)(SWIG_As_int(obj2));
10986 if (SWIG_arg_fail(3)) SWIG_fail;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 (arg1)->base_OnTerminate(arg2,arg3);
10991
10992 wxPyEndAllowThreads(__tstate);
10993 if (PyErr_Occurred()) SWIG_fail;
10994 }
10995 Py_INCREF(Py_None); resultobj = Py_None;
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11003 PyObject *resultobj;
11004 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 (arg1)->Redirect();
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 Py_INCREF(Py_None); resultobj = Py_None;
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj;
11029 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11030 bool result;
11031 PyObject * obj0 = 0 ;
11032 char *kwnames[] = {
11033 (char *) "self", NULL
11034 };
11035
11036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11038 if (SWIG_arg_fail(1)) SWIG_fail;
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = (bool)(arg1)->IsRedirected();
11042
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj;
11057 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11058 PyObject * obj0 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 (arg1)->Detach();
11069
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 Py_INCREF(Py_None); resultobj = Py_None;
11074 return resultobj;
11075 fail:
11076 return NULL;
11077 }
11078
11079
11080 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11081 PyObject *resultobj;
11082 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11083 wxInputStream *result;
11084 PyObject * obj0 = 0 ;
11085 char *kwnames[] = {
11086 (char *) "self", NULL
11087 };
11088
11089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11091 if (SWIG_arg_fail(1)) SWIG_fail;
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (wxInputStream *)(arg1)->GetInputStream();
11095
11096 wxPyEndAllowThreads(__tstate);
11097 if (PyErr_Occurred()) SWIG_fail;
11098 }
11099 {
11100 wxPyInputStream * _ptr = NULL;
11101
11102 if (result) {
11103 _ptr = new wxPyInputStream(result);
11104 }
11105 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11106 }
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11116 wxInputStream *result;
11117 PyObject * obj0 = 0 ;
11118 char *kwnames[] = {
11119 (char *) "self", NULL
11120 };
11121
11122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11124 if (SWIG_arg_fail(1)) SWIG_fail;
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxInputStream *)(arg1)->GetErrorStream();
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 {
11133 wxPyInputStream * _ptr = NULL;
11134
11135 if (result) {
11136 _ptr = new wxPyInputStream(result);
11137 }
11138 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11149 wxOutputStream *result;
11150 PyObject * obj0 = 0 ;
11151 char *kwnames[] = {
11152 (char *) "self", NULL
11153 };
11154
11155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11157 if (SWIG_arg_fail(1)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (wxOutputStream *)(arg1)->GetOutputStream();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11175 PyObject * obj0 = 0 ;
11176 char *kwnames[] = {
11177 (char *) "self", NULL
11178 };
11179
11180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11182 if (SWIG_arg_fail(1)) SWIG_fail;
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 (arg1)->CloseOutput();
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 Py_INCREF(Py_None); resultobj = Py_None;
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11198 PyObject *resultobj;
11199 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11200 bool result;
11201 PyObject * obj0 = 0 ;
11202 char *kwnames[] = {
11203 (char *) "self", NULL
11204 };
11205
11206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11208 if (SWIG_arg_fail(1)) SWIG_fail;
11209 {
11210 PyThreadState* __tstate = wxPyBeginAllowThreads();
11211 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11212
11213 wxPyEndAllowThreads(__tstate);
11214 if (PyErr_Occurred()) SWIG_fail;
11215 }
11216 {
11217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11218 }
11219 return resultobj;
11220 fail:
11221 return NULL;
11222 }
11223
11224
11225 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11226 PyObject *resultobj;
11227 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11228 bool result;
11229 PyObject * obj0 = 0 ;
11230 char *kwnames[] = {
11231 (char *) "self", NULL
11232 };
11233
11234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11236 if (SWIG_arg_fail(1)) SWIG_fail;
11237 {
11238 PyThreadState* __tstate = wxPyBeginAllowThreads();
11239 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11240
11241 wxPyEndAllowThreads(__tstate);
11242 if (PyErr_Occurred()) SWIG_fail;
11243 }
11244 {
11245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11246 }
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11256 bool result;
11257 PyObject * obj0 = 0 ;
11258 char *kwnames[] = {
11259 (char *) "self", NULL
11260 };
11261
11262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11264 if (SWIG_arg_fail(1)) SWIG_fail;
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11268
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 {
11273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11274 }
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11282 PyObject *obj;
11283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11284 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11285 Py_INCREF(obj);
11286 return Py_BuildValue((char *)"");
11287 }
11288 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj;
11290 int arg1 = (int) 0 ;
11291 int arg2 = (int) 0 ;
11292 int arg3 = (int) 0 ;
11293 wxProcessEvent *result;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 PyObject * obj2 = 0 ;
11297 char *kwnames[] = {
11298 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11299 };
11300
11301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11302 if (obj0) {
11303 {
11304 arg1 = (int)(SWIG_As_int(obj0));
11305 if (SWIG_arg_fail(1)) SWIG_fail;
11306 }
11307 }
11308 if (obj1) {
11309 {
11310 arg2 = (int)(SWIG_As_int(obj1));
11311 if (SWIG_arg_fail(2)) SWIG_fail;
11312 }
11313 }
11314 if (obj2) {
11315 {
11316 arg3 = (int)(SWIG_As_int(obj2));
11317 if (SWIG_arg_fail(3)) SWIG_fail;
11318 }
11319 }
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj;
11336 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11337 int result;
11338 PyObject * obj0 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "self", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11345 if (SWIG_arg_fail(1)) SWIG_fail;
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 result = (int)(arg1)->GetPid();
11349
11350 wxPyEndAllowThreads(__tstate);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 {
11354 resultobj = SWIG_From_int((int)(result));
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj;
11364 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11365 int result;
11366 PyObject * obj0 = 0 ;
11367 char *kwnames[] = {
11368 (char *) "self", NULL
11369 };
11370
11371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11373 if (SWIG_arg_fail(1)) SWIG_fail;
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (int)(arg1)->GetExitCode();
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = SWIG_From_int((int)(result));
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11393 int arg2 ;
11394 PyObject * obj0 = 0 ;
11395 PyObject * obj1 = 0 ;
11396 char *kwnames[] = {
11397 (char *) "self",(char *) "m_pid", NULL
11398 };
11399
11400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11402 if (SWIG_arg_fail(1)) SWIG_fail;
11403 {
11404 arg2 = (int)(SWIG_As_int(obj1));
11405 if (SWIG_arg_fail(2)) SWIG_fail;
11406 }
11407 if (arg1) (arg1)->m_pid = arg2;
11408
11409 Py_INCREF(Py_None); resultobj = Py_None;
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11419 int result;
11420 PyObject * obj0 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "self", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11427 if (SWIG_arg_fail(1)) SWIG_fail;
11428 result = (int) ((arg1)->m_pid);
11429
11430 {
11431 resultobj = SWIG_From_int((int)(result));
11432 }
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj;
11441 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11442 int arg2 ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "m_exitcode", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = (int)(SWIG_As_int(obj1));
11454 if (SWIG_arg_fail(2)) SWIG_fail;
11455 }
11456 if (arg1) (arg1)->m_exitcode = arg2;
11457
11458 Py_INCREF(Py_None); resultobj = Py_None;
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj;
11467 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11468 int result;
11469 PyObject * obj0 = 0 ;
11470 char *kwnames[] = {
11471 (char *) "self", NULL
11472 };
11473
11474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11476 if (SWIG_arg_fail(1)) SWIG_fail;
11477 result = (int) ((arg1)->m_exitcode);
11478
11479 {
11480 resultobj = SWIG_From_int((int)(result));
11481 }
11482 return resultobj;
11483 fail:
11484 return NULL;
11485 }
11486
11487
11488 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11489 PyObject *obj;
11490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11491 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11492 Py_INCREF(obj);
11493 return Py_BuildValue((char *)"");
11494 }
11495 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11496 PyObject *resultobj;
11497 wxString *arg1 = 0 ;
11498 int arg2 = (int) wxEXEC_ASYNC ;
11499 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11500 long result;
11501 bool temp1 = false ;
11502 PyObject * obj0 = 0 ;
11503 PyObject * obj1 = 0 ;
11504 PyObject * obj2 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "command",(char *) "flags",(char *) "process", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11510 {
11511 arg1 = wxString_in_helper(obj0);
11512 if (arg1 == NULL) SWIG_fail;
11513 temp1 = true;
11514 }
11515 if (obj1) {
11516 {
11517 arg2 = (int)(SWIG_As_int(obj1));
11518 if (SWIG_arg_fail(2)) SWIG_fail;
11519 }
11520 }
11521 if (obj2) {
11522 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11523 if (SWIG_arg_fail(3)) SWIG_fail;
11524 }
11525 {
11526 if (!wxPyCheckForApp()) SWIG_fail;
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11529
11530 wxPyEndAllowThreads(__tstate);
11531 if (PyErr_Occurred()) SWIG_fail;
11532 }
11533 {
11534 resultobj = SWIG_From_long((long)(result));
11535 }
11536 {
11537 if (temp1)
11538 delete arg1;
11539 }
11540 return resultobj;
11541 fail:
11542 {
11543 if (temp1)
11544 delete arg1;
11545 }
11546 return NULL;
11547 }
11548
11549
11550 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 long arg1 ;
11553 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11554 wxKillError *arg3 = (wxKillError *) 0 ;
11555 int arg4 = (int) wxKILL_NOCHILDREN ;
11556 int result;
11557 wxKillError temp3 ;
11558 PyObject * obj0 = 0 ;
11559 PyObject * obj1 = 0 ;
11560 PyObject * obj2 = 0 ;
11561 char *kwnames[] = {
11562 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11563 };
11564
11565 {
11566 arg3 = &temp3;
11567 }
11568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11569 {
11570 arg1 = (long)(SWIG_As_long(obj0));
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 }
11573 if (obj1) {
11574 {
11575 arg2 = (wxSignal)(SWIG_As_int(obj1));
11576 if (SWIG_arg_fail(2)) SWIG_fail;
11577 }
11578 }
11579 if (obj2) {
11580 {
11581 arg4 = (int)(SWIG_As_int(obj2));
11582 if (SWIG_arg_fail(4)) SWIG_fail;
11583 }
11584 }
11585 {
11586 PyThreadState* __tstate = wxPyBeginAllowThreads();
11587 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11588
11589 wxPyEndAllowThreads(__tstate);
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 {
11593 resultobj = SWIG_From_int((int)(result));
11594 }
11595 {
11596 PyObject* o;
11597 o = PyInt_FromLong((long) (*arg3));
11598 resultobj = t_output_helper(resultobj, o);
11599 }
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj;
11608 int arg1 = (int) wxJOYSTICK1 ;
11609 wxJoystick *result;
11610 PyObject * obj0 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "joystick", NULL
11613 };
11614
11615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11616 if (obj0) {
11617 {
11618 arg1 = (int)(SWIG_As_int(obj0));
11619 if (SWIG_arg_fail(1)) SWIG_fail;
11620 }
11621 }
11622 {
11623 if (!wxPyCheckForApp()) SWIG_fail;
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (wxJoystick *)new wxJoystick(arg1);
11626
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj;
11639 wxJoystick *arg1 = (wxJoystick *) 0 ;
11640 PyObject * obj0 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 delete arg1;
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 Py_INCREF(Py_None); resultobj = Py_None;
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj;
11664 wxJoystick *arg1 = (wxJoystick *) 0 ;
11665 wxPoint result;
11666 PyObject * obj0 = 0 ;
11667 char *kwnames[] = {
11668 (char *) "self", NULL
11669 };
11670
11671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 result = (arg1)->GetPosition();
11677
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 {
11682 wxPoint * resultptr;
11683 resultptr = new wxPoint((wxPoint &)(result));
11684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11685 }
11686 return resultobj;
11687 fail:
11688 return NULL;
11689 }
11690
11691
11692 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11693 PyObject *resultobj;
11694 wxJoystick *arg1 = (wxJoystick *) 0 ;
11695 int result;
11696 PyObject * obj0 = 0 ;
11697 char *kwnames[] = {
11698 (char *) "self", NULL
11699 };
11700
11701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11703 if (SWIG_arg_fail(1)) SWIG_fail;
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (int)(arg1)->GetZPosition();
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 resultobj = SWIG_From_int((int)(result));
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11721 PyObject *resultobj;
11722 wxJoystick *arg1 = (wxJoystick *) 0 ;
11723 int result;
11724 PyObject * obj0 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "self", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(1)) SWIG_fail;
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 result = (int)(arg1)->GetButtonState();
11735
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 {
11740 resultobj = SWIG_From_int((int)(result));
11741 }
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj;
11750 wxJoystick *arg1 = (wxJoystick *) 0 ;
11751 int result;
11752 PyObject * obj0 = 0 ;
11753 char *kwnames[] = {
11754 (char *) "self", NULL
11755 };
11756
11757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11759 if (SWIG_arg_fail(1)) SWIG_fail;
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 result = (int)(arg1)->GetPOVPosition();
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 {
11768 resultobj = SWIG_From_int((int)(result));
11769 }
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj;
11778 wxJoystick *arg1 = (wxJoystick *) 0 ;
11779 int result;
11780 PyObject * obj0 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "self", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11787 if (SWIG_arg_fail(1)) SWIG_fail;
11788 {
11789 PyThreadState* __tstate = wxPyBeginAllowThreads();
11790 result = (int)(arg1)->GetPOVCTSPosition();
11791
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 {
11796 resultobj = SWIG_From_int((int)(result));
11797 }
11798 return resultobj;
11799 fail:
11800 return NULL;
11801 }
11802
11803
11804 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11805 PyObject *resultobj;
11806 wxJoystick *arg1 = (wxJoystick *) 0 ;
11807 int result;
11808 PyObject * obj0 = 0 ;
11809 char *kwnames[] = {
11810 (char *) "self", NULL
11811 };
11812
11813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11815 if (SWIG_arg_fail(1)) SWIG_fail;
11816 {
11817 PyThreadState* __tstate = wxPyBeginAllowThreads();
11818 result = (int)(arg1)->GetRudderPosition();
11819
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 {
11824 resultobj = SWIG_From_int((int)(result));
11825 }
11826 return resultobj;
11827 fail:
11828 return NULL;
11829 }
11830
11831
11832 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11833 PyObject *resultobj;
11834 wxJoystick *arg1 = (wxJoystick *) 0 ;
11835 int result;
11836 PyObject * obj0 = 0 ;
11837 char *kwnames[] = {
11838 (char *) "self", NULL
11839 };
11840
11841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11843 if (SWIG_arg_fail(1)) SWIG_fail;
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = (int)(arg1)->GetUPosition();
11847
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 resultobj = SWIG_From_int((int)(result));
11853 }
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj;
11862 wxJoystick *arg1 = (wxJoystick *) 0 ;
11863 int result;
11864 PyObject * obj0 = 0 ;
11865 char *kwnames[] = {
11866 (char *) "self", NULL
11867 };
11868
11869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11871 if (SWIG_arg_fail(1)) SWIG_fail;
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (int)(arg1)->GetVPosition();
11875
11876 wxPyEndAllowThreads(__tstate);
11877 if (PyErr_Occurred()) SWIG_fail;
11878 }
11879 {
11880 resultobj = SWIG_From_int((int)(result));
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj;
11890 wxJoystick *arg1 = (wxJoystick *) 0 ;
11891 int result;
11892 PyObject * obj0 = 0 ;
11893 char *kwnames[] = {
11894 (char *) "self", NULL
11895 };
11896
11897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11899 if (SWIG_arg_fail(1)) SWIG_fail;
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (int)(arg1)->GetMovementThreshold();
11903
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 {
11908 resultobj = SWIG_From_int((int)(result));
11909 }
11910 return resultobj;
11911 fail:
11912 return NULL;
11913 }
11914
11915
11916 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj;
11918 wxJoystick *arg1 = (wxJoystick *) 0 ;
11919 int arg2 ;
11920 PyObject * obj0 = 0 ;
11921 PyObject * obj1 = 0 ;
11922 char *kwnames[] = {
11923 (char *) "self",(char *) "threshold", NULL
11924 };
11925
11926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11928 if (SWIG_arg_fail(1)) SWIG_fail;
11929 {
11930 arg2 = (int)(SWIG_As_int(obj1));
11931 if (SWIG_arg_fail(2)) SWIG_fail;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetMovementThreshold(arg2);
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 Py_INCREF(Py_None); resultobj = Py_None;
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxJoystick *arg1 = (wxJoystick *) 0 ;
11950 bool result;
11951 PyObject * obj0 = 0 ;
11952 char *kwnames[] = {
11953 (char *) "self", NULL
11954 };
11955
11956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11958 if (SWIG_arg_fail(1)) SWIG_fail;
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (bool)(arg1)->IsOk();
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj;
11977 wxJoystick *arg1 = (wxJoystick *) 0 ;
11978 int result;
11979 PyObject * obj0 = 0 ;
11980 char *kwnames[] = {
11981 (char *) "self", NULL
11982 };
11983
11984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11986 if (SWIG_arg_fail(1)) SWIG_fail;
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (int)(arg1)->GetNumberJoysticks();
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = SWIG_From_int((int)(result));
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxJoystick *arg1 = (wxJoystick *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetManufacturerId();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxJoystick *arg1 = (wxJoystick *) 0 ;
12034 int result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (int)(arg1)->GetProductId();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = SWIG_From_int((int)(result));
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 wxString result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (arg1)->GetProductName();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 #if wxUSE_UNICODE
12080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12081 #else
12082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12083 #endif
12084 }
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj;
12093 wxJoystick *arg1 = (wxJoystick *) 0 ;
12094 int result;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (int)(arg1)->GetXMin();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 resultobj = SWIG_From_int((int)(result));
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxJoystick *arg1 = (wxJoystick *) 0 ;
12122 int result;
12123 PyObject * obj0 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "self", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (int)(arg1)->GetYMin();
12134
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = SWIG_From_int((int)(result));
12140 }
12141 return resultobj;
12142 fail:
12143 return NULL;
12144 }
12145
12146
12147 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12148 PyObject *resultobj;
12149 wxJoystick *arg1 = (wxJoystick *) 0 ;
12150 int result;
12151 PyObject * obj0 = 0 ;
12152 char *kwnames[] = {
12153 (char *) "self", NULL
12154 };
12155
12156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12158 if (SWIG_arg_fail(1)) SWIG_fail;
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (int)(arg1)->GetZMin();
12162
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 {
12167 resultobj = SWIG_From_int((int)(result));
12168 }
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxJoystick *arg1 = (wxJoystick *) 0 ;
12178 int result;
12179 PyObject * obj0 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (int)(arg1)->GetXMax();
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 {
12195 resultobj = SWIG_From_int((int)(result));
12196 }
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12204 PyObject *resultobj;
12205 wxJoystick *arg1 = (wxJoystick *) 0 ;
12206 int result;
12207 PyObject * obj0 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (int)(arg1)->GetYMax();
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = SWIG_From_int((int)(result));
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj;
12233 wxJoystick *arg1 = (wxJoystick *) 0 ;
12234 int result;
12235 PyObject * obj0 = 0 ;
12236 char *kwnames[] = {
12237 (char *) "self", NULL
12238 };
12239
12240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12242 if (SWIG_arg_fail(1)) SWIG_fail;
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (int)(arg1)->GetZMax();
12246
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 {
12251 resultobj = SWIG_From_int((int)(result));
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj;
12261 wxJoystick *arg1 = (wxJoystick *) 0 ;
12262 int result;
12263 PyObject * obj0 = 0 ;
12264 char *kwnames[] = {
12265 (char *) "self", NULL
12266 };
12267
12268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12270 if (SWIG_arg_fail(1)) SWIG_fail;
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (int)(arg1)->GetNumberButtons();
12274
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 {
12279 resultobj = SWIG_From_int((int)(result));
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj;
12289 wxJoystick *arg1 = (wxJoystick *) 0 ;
12290 int result;
12291 PyObject * obj0 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "self", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(1)) SWIG_fail;
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = (int)(arg1)->GetNumberAxes();
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 resultobj = SWIG_From_int((int)(result));
12308 }
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj;
12317 wxJoystick *arg1 = (wxJoystick *) 0 ;
12318 int result;
12319 PyObject * obj0 = 0 ;
12320 char *kwnames[] = {
12321 (char *) "self", NULL
12322 };
12323
12324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12326 if (SWIG_arg_fail(1)) SWIG_fail;
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (int)(arg1)->GetMaxButtons();
12330
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 {
12335 resultobj = SWIG_From_int((int)(result));
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj;
12345 wxJoystick *arg1 = (wxJoystick *) 0 ;
12346 int result;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (int)(arg1)->GetMaxAxes();
12358
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 {
12363 resultobj = SWIG_From_int((int)(result));
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj;
12373 wxJoystick *arg1 = (wxJoystick *) 0 ;
12374 int result;
12375 PyObject * obj0 = 0 ;
12376 char *kwnames[] = {
12377 (char *) "self", NULL
12378 };
12379
12380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12382 if (SWIG_arg_fail(1)) SWIG_fail;
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (int)(arg1)->GetPollingMin();
12386
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 {
12391 resultobj = SWIG_From_int((int)(result));
12392 }
12393 return resultobj;
12394 fail:
12395 return NULL;
12396 }
12397
12398
12399 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12400 PyObject *resultobj;
12401 wxJoystick *arg1 = (wxJoystick *) 0 ;
12402 int result;
12403 PyObject * obj0 = 0 ;
12404 char *kwnames[] = {
12405 (char *) "self", NULL
12406 };
12407
12408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12410 if (SWIG_arg_fail(1)) SWIG_fail;
12411 {
12412 PyThreadState* __tstate = wxPyBeginAllowThreads();
12413 result = (int)(arg1)->GetPollingMax();
12414
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 {
12419 resultobj = SWIG_From_int((int)(result));
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxJoystick *arg1 = (wxJoystick *) 0 ;
12430 int result;
12431 PyObject * obj0 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 result = (int)(arg1)->GetRudderMin();
12442
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 {
12447 resultobj = SWIG_From_int((int)(result));
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxJoystick *arg1 = (wxJoystick *) 0 ;
12458 int result;
12459 PyObject * obj0 = 0 ;
12460 char *kwnames[] = {
12461 (char *) "self", NULL
12462 };
12463
12464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12466 if (SWIG_arg_fail(1)) SWIG_fail;
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 result = (int)(arg1)->GetRudderMax();
12470
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 {
12475 resultobj = SWIG_From_int((int)(result));
12476 }
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj;
12485 wxJoystick *arg1 = (wxJoystick *) 0 ;
12486 int result;
12487 PyObject * obj0 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (int)(arg1)->GetUMin();
12498
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 {
12503 resultobj = SWIG_From_int((int)(result));
12504 }
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj;
12513 wxJoystick *arg1 = (wxJoystick *) 0 ;
12514 int result;
12515 PyObject * obj0 = 0 ;
12516 char *kwnames[] = {
12517 (char *) "self", NULL
12518 };
12519
12520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12522 if (SWIG_arg_fail(1)) SWIG_fail;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (int)(arg1)->GetUMax();
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 {
12531 resultobj = SWIG_From_int((int)(result));
12532 }
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxJoystick *arg1 = (wxJoystick *) 0 ;
12542 int result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (int)(arg1)->GetVMin();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = SWIG_From_int((int)(result));
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxJoystick *arg1 = (wxJoystick *) 0 ;
12570 int result;
12571 PyObject * obj0 = 0 ;
12572 char *kwnames[] = {
12573 (char *) "self", NULL
12574 };
12575
12576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12578 if (SWIG_arg_fail(1)) SWIG_fail;
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 result = (int)(arg1)->GetVMax();
12582
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 {
12587 resultobj = SWIG_From_int((int)(result));
12588 }
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj;
12597 wxJoystick *arg1 = (wxJoystick *) 0 ;
12598 bool result;
12599 PyObject * obj0 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 PyThreadState* __tstate = wxPyBeginAllowThreads();
12609 result = (bool)(arg1)->HasRudder();
12610
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 {
12615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12616 }
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12624 PyObject *resultobj;
12625 wxJoystick *arg1 = (wxJoystick *) 0 ;
12626 bool result;
12627 PyObject * obj0 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 PyThreadState* __tstate = wxPyBeginAllowThreads();
12637 result = (bool)(arg1)->HasZ();
12638
12639 wxPyEndAllowThreads(__tstate);
12640 if (PyErr_Occurred()) SWIG_fail;
12641 }
12642 {
12643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12644 }
12645 return resultobj;
12646 fail:
12647 return NULL;
12648 }
12649
12650
12651 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj;
12653 wxJoystick *arg1 = (wxJoystick *) 0 ;
12654 bool result;
12655 PyObject * obj0 = 0 ;
12656 char *kwnames[] = {
12657 (char *) "self", NULL
12658 };
12659
12660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12662 if (SWIG_arg_fail(1)) SWIG_fail;
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (bool)(arg1)->HasU();
12666
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12672 }
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxJoystick *arg1 = (wxJoystick *) 0 ;
12682 bool result;
12683 PyObject * obj0 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (bool)(arg1)->HasV();
12694
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 {
12699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12700 }
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj;
12709 wxJoystick *arg1 = (wxJoystick *) 0 ;
12710 bool result;
12711 PyObject * obj0 = 0 ;
12712 char *kwnames[] = {
12713 (char *) "self", NULL
12714 };
12715
12716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(1)) SWIG_fail;
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (bool)(arg1)->HasPOV();
12722
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 {
12727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12728 }
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxJoystick *arg1 = (wxJoystick *) 0 ;
12738 bool result;
12739 PyObject * obj0 = 0 ;
12740 char *kwnames[] = {
12741 (char *) "self", NULL
12742 };
12743
12744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(1)) SWIG_fail;
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 result = (bool)(arg1)->HasPOV4Dir();
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12756 }
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxJoystick *arg1 = (wxJoystick *) 0 ;
12766 bool result;
12767 PyObject * obj0 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (bool)(arg1)->HasPOVCTS();
12778
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 {
12783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12784 }
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxJoystick *arg1 = (wxJoystick *) 0 ;
12794 wxWindow *arg2 = (wxWindow *) 0 ;
12795 int arg3 = (int) 0 ;
12796 bool result;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 PyObject * obj2 = 0 ;
12800 char *kwnames[] = {
12801 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12802 };
12803
12804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(2)) SWIG_fail;
12809 if (obj2) {
12810 {
12811 arg3 = (int)(SWIG_As_int(obj2));
12812 if (SWIG_arg_fail(3)) SWIG_fail;
12813 }
12814 }
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (bool)(arg1)->SetCapture(arg2,arg3);
12818
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 {
12823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12824 }
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj;
12833 wxJoystick *arg1 = (wxJoystick *) 0 ;
12834 bool result;
12835 PyObject * obj0 = 0 ;
12836 char *kwnames[] = {
12837 (char *) "self", NULL
12838 };
12839
12840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12842 if (SWIG_arg_fail(1)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (bool)(arg1)->ReleaseCapture();
12846
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 {
12851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12852 }
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12860 PyObject *obj;
12861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12862 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12863 Py_INCREF(obj);
12864 return Py_BuildValue((char *)"");
12865 }
12866 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12869 int arg2 = (int) 0 ;
12870 int arg3 = (int) wxJOYSTICK1 ;
12871 int arg4 = (int) 0 ;
12872 wxJoystickEvent *result;
12873 PyObject * obj0 = 0 ;
12874 PyObject * obj1 = 0 ;
12875 PyObject * obj2 = 0 ;
12876 PyObject * obj3 = 0 ;
12877 char *kwnames[] = {
12878 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12879 };
12880
12881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12882 if (obj0) {
12883 {
12884 arg1 = (wxEventType)(SWIG_As_int(obj0));
12885 if (SWIG_arg_fail(1)) SWIG_fail;
12886 }
12887 }
12888 if (obj1) {
12889 {
12890 arg2 = (int)(SWIG_As_int(obj1));
12891 if (SWIG_arg_fail(2)) SWIG_fail;
12892 }
12893 }
12894 if (obj2) {
12895 {
12896 arg3 = (int)(SWIG_As_int(obj2));
12897 if (SWIG_arg_fail(3)) SWIG_fail;
12898 }
12899 }
12900 if (obj3) {
12901 {
12902 arg4 = (int)(SWIG_As_int(obj3));
12903 if (SWIG_arg_fail(4)) SWIG_fail;
12904 }
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12923 wxPoint result;
12924 PyObject * obj0 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 {
12940 wxPoint * resultptr;
12941 resultptr = new wxPoint((wxPoint &)(result));
12942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12943 }
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12953 int result;
12954 PyObject * obj0 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12965
12966 wxPyEndAllowThreads(__tstate);
12967 if (PyErr_Occurred()) SWIG_fail;
12968 }
12969 {
12970 resultobj = SWIG_From_int((int)(result));
12971 }
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj;
12980 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12981 int result;
12982 PyObject * obj0 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12993
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 {
12998 resultobj = SWIG_From_int((int)(result));
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13009 int result;
13010 PyObject * obj0 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 {
13026 resultobj = SWIG_From_int((int)(result));
13027 }
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj;
13036 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13037 int result;
13038 PyObject * obj0 = 0 ;
13039 char *kwnames[] = {
13040 (char *) "self", NULL
13041 };
13042
13043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13045 if (SWIG_arg_fail(1)) SWIG_fail;
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13049
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 {
13054 resultobj = SWIG_From_int((int)(result));
13055 }
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13065 int arg2 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 char *kwnames[] = {
13069 (char *) "self",(char *) "stick", NULL
13070 };
13071
13072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13074 if (SWIG_arg_fail(1)) SWIG_fail;
13075 {
13076 arg2 = (int)(SWIG_As_int(obj1));
13077 if (SWIG_arg_fail(2)) SWIG_fail;
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 (arg1)->SetJoystick(arg2);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 Py_INCREF(Py_None); resultobj = Py_None;
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13094 PyObject *resultobj;
13095 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13096 int arg2 ;
13097 PyObject * obj0 = 0 ;
13098 PyObject * obj1 = 0 ;
13099 char *kwnames[] = {
13100 (char *) "self",(char *) "state", NULL
13101 };
13102
13103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(1)) SWIG_fail;
13106 {
13107 arg2 = (int)(SWIG_As_int(obj1));
13108 if (SWIG_arg_fail(2)) SWIG_fail;
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 (arg1)->SetButtonState(arg2);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 Py_INCREF(Py_None); resultobj = Py_None;
13118 return resultobj;
13119 fail:
13120 return NULL;
13121 }
13122
13123
13124 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13125 PyObject *resultobj;
13126 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13127 int arg2 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "change", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 arg2 = (int)(SWIG_As_int(obj1));
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 (arg1)->SetButtonChange(arg2);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 Py_INCREF(Py_None); resultobj = Py_None;
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13158 wxPoint *arg2 = 0 ;
13159 wxPoint temp2 ;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "self",(char *) "pos", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 {
13170 arg2 = &temp2;
13171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13172 }
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 (arg1)->SetPosition((wxPoint const &)*arg2);
13176
13177 wxPyEndAllowThreads(__tstate);
13178 if (PyErr_Occurred()) SWIG_fail;
13179 }
13180 Py_INCREF(Py_None); resultobj = Py_None;
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13190 int arg2 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self",(char *) "zPos", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13199 if (SWIG_arg_fail(1)) SWIG_fail;
13200 {
13201 arg2 = (int)(SWIG_As_int(obj1));
13202 if (SWIG_arg_fail(2)) SWIG_fail;
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 (arg1)->SetZPosition(arg2);
13207
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 Py_INCREF(Py_None); resultobj = Py_None;
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj;
13220 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13221 bool result;
13222 PyObject * obj0 = 0 ;
13223 char *kwnames[] = {
13224 (char *) "self", NULL
13225 };
13226
13227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13229 if (SWIG_arg_fail(1)) SWIG_fail;
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13233
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13239 }
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj;
13248 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13249 bool result;
13250 PyObject * obj0 = 0 ;
13251 char *kwnames[] = {
13252 (char *) "self", NULL
13253 };
13254
13255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13257 if (SWIG_arg_fail(1)) SWIG_fail;
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13261
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 {
13266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13267 }
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj;
13276 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13277 bool result;
13278 PyObject * obj0 = 0 ;
13279 char *kwnames[] = {
13280 (char *) "self", NULL
13281 };
13282
13283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13285 if (SWIG_arg_fail(1)) SWIG_fail;
13286 {
13287 PyThreadState* __tstate = wxPyBeginAllowThreads();
13288 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13289
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13295 }
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj;
13304 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13305 int arg2 = (int) wxJOY_BUTTON_ANY ;
13306 bool result;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 char *kwnames[] = {
13310 (char *) "self",(char *) "but", NULL
13311 };
13312
13313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13315 if (SWIG_arg_fail(1)) SWIG_fail;
13316 if (obj1) {
13317 {
13318 arg2 = (int)(SWIG_As_int(obj1));
13319 if (SWIG_arg_fail(2)) SWIG_fail;
13320 }
13321 }
13322 {
13323 PyThreadState* __tstate = wxPyBeginAllowThreads();
13324 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13325
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 {
13330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13331 }
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13341 int arg2 = (int) wxJOY_BUTTON_ANY ;
13342 bool result;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "self",(char *) "but", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13351 if (SWIG_arg_fail(1)) SWIG_fail;
13352 if (obj1) {
13353 {
13354 arg2 = (int)(SWIG_As_int(obj1));
13355 if (SWIG_arg_fail(2)) SWIG_fail;
13356 }
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 {
13366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13367 }
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj;
13376 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13377 int arg2 = (int) wxJOY_BUTTON_ANY ;
13378 bool result;
13379 PyObject * obj0 = 0 ;
13380 PyObject * obj1 = 0 ;
13381 char *kwnames[] = {
13382 (char *) "self",(char *) "but", NULL
13383 };
13384
13385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13387 if (SWIG_arg_fail(1)) SWIG_fail;
13388 if (obj1) {
13389 {
13390 arg2 = (int)(SWIG_As_int(obj1));
13391 if (SWIG_arg_fail(2)) SWIG_fail;
13392 }
13393 }
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13397
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 {
13402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13403 }
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13411 PyObject *obj;
13412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13413 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13414 Py_INCREF(obj);
13415 return Py_BuildValue((char *)"");
13416 }
13417 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj;
13419 wxString const &arg1_defvalue = wxPyEmptyString ;
13420 wxString *arg1 = (wxString *) &arg1_defvalue ;
13421 wxSound *result;
13422 bool temp1 = false ;
13423 PyObject * obj0 = 0 ;
13424 char *kwnames[] = {
13425 (char *) "fileName", NULL
13426 };
13427
13428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13429 if (obj0) {
13430 {
13431 arg1 = wxString_in_helper(obj0);
13432 if (arg1 == NULL) SWIG_fail;
13433 temp1 = true;
13434 }
13435 }
13436 {
13437 if (!wxPyCheckForApp()) SWIG_fail;
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 return resultobj;
13450 fail:
13451 {
13452 if (temp1)
13453 delete arg1;
13454 }
13455 return NULL;
13456 }
13457
13458
13459 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13460 PyObject *resultobj;
13461 PyObject *arg1 = (PyObject *) 0 ;
13462 wxSound *result;
13463 PyObject * obj0 = 0 ;
13464 char *kwnames[] = {
13465 (char *) "data", NULL
13466 };
13467
13468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13469 arg1 = obj0;
13470 {
13471 if (!wxPyCheckForApp()) SWIG_fail;
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 result = (wxSound *)new_wxSound(arg1);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj;
13487 wxSound *arg1 = (wxSound *) 0 ;
13488 PyObject * obj0 = 0 ;
13489 char *kwnames[] = {
13490 (char *) "self", NULL
13491 };
13492
13493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13495 if (SWIG_arg_fail(1)) SWIG_fail;
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 delete arg1;
13499
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 Py_INCREF(Py_None); resultobj = Py_None;
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxSound *arg1 = (wxSound *) 0 ;
13513 wxString *arg2 = 0 ;
13514 bool result;
13515 bool temp2 = false ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "fileName", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)(arg1)->Create((wxString const &)*arg2);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 {
13541 if (temp2)
13542 delete arg2;
13543 }
13544 return resultobj;
13545 fail:
13546 {
13547 if (temp2)
13548 delete arg2;
13549 }
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxSound *arg1 = (wxSound *) 0 ;
13557 PyObject *arg2 = (PyObject *) 0 ;
13558 bool result;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "data", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 arg2 = obj1;
13569 {
13570 PyThreadState* __tstate = wxPyBeginAllowThreads();
13571 result = (bool)wxSound_CreateFromData(arg1,arg2);
13572
13573 wxPyEndAllowThreads(__tstate);
13574 if (PyErr_Occurred()) SWIG_fail;
13575 }
13576 {
13577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13578 }
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj;
13587 wxSound *arg1 = (wxSound *) 0 ;
13588 bool result;
13589 PyObject * obj0 = 0 ;
13590 char *kwnames[] = {
13591 (char *) "self", NULL
13592 };
13593
13594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13596 if (SWIG_arg_fail(1)) SWIG_fail;
13597 {
13598 PyThreadState* __tstate = wxPyBeginAllowThreads();
13599 result = (bool)(arg1)->IsOk();
13600
13601 wxPyEndAllowThreads(__tstate);
13602 if (PyErr_Occurred()) SWIG_fail;
13603 }
13604 {
13605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13606 }
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj;
13615 wxSound *arg1 = (wxSound *) 0 ;
13616 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13617 bool result;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 char *kwnames[] = {
13621 (char *) "self",(char *) "flags", NULL
13622 };
13623
13624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13626 if (SWIG_arg_fail(1)) SWIG_fail;
13627 if (obj1) {
13628 {
13629 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13630 if (SWIG_arg_fail(2)) SWIG_fail;
13631 }
13632 }
13633 {
13634 if (!wxPyCheckForApp()) SWIG_fail;
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (bool)((wxSound const *)arg1)->Play(arg2);
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 {
13642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13643 }
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj;
13652 wxString *arg1 = 0 ;
13653 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13654 bool result;
13655 bool temp1 = false ;
13656 PyObject * obj0 = 0 ;
13657 PyObject * obj1 = 0 ;
13658 char *kwnames[] = {
13659 (char *) "filename",(char *) "flags", NULL
13660 };
13661
13662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13663 {
13664 arg1 = wxString_in_helper(obj0);
13665 if (arg1 == NULL) SWIG_fail;
13666 temp1 = true;
13667 }
13668 if (obj1) {
13669 {
13670 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13671 if (SWIG_arg_fail(2)) SWIG_fail;
13672 }
13673 }
13674 {
13675 if (!wxPyCheckForApp()) SWIG_fail;
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13678
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 {
13683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13684 }
13685 {
13686 if (temp1)
13687 delete arg1;
13688 }
13689 return resultobj;
13690 fail:
13691 {
13692 if (temp1)
13693 delete arg1;
13694 }
13695 return NULL;
13696 }
13697
13698
13699 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13700 PyObject *resultobj;
13701 char *kwnames[] = {
13702 NULL
13703 };
13704
13705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13706 {
13707 if (!wxPyCheckForApp()) SWIG_fail;
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 wxSound::Stop();
13710
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 Py_INCREF(Py_None); resultobj = Py_None;
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13722 PyObject *obj;
13723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13724 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13725 Py_INCREF(obj);
13726 return Py_BuildValue((char *)"");
13727 }
13728 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj;
13730 wxString *arg1 = 0 ;
13731 wxString *arg2 = 0 ;
13732 wxString *arg3 = 0 ;
13733 wxString *arg4 = 0 ;
13734 wxFileTypeInfo *result;
13735 bool temp1 = false ;
13736 bool temp2 = false ;
13737 bool temp3 = false ;
13738 bool temp4 = false ;
13739 PyObject * obj0 = 0 ;
13740 PyObject * obj1 = 0 ;
13741 PyObject * obj2 = 0 ;
13742 PyObject * obj3 = 0 ;
13743 char *kwnames[] = {
13744 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13748 {
13749 arg1 = wxString_in_helper(obj0);
13750 if (arg1 == NULL) SWIG_fail;
13751 temp1 = true;
13752 }
13753 {
13754 arg2 = wxString_in_helper(obj1);
13755 if (arg2 == NULL) SWIG_fail;
13756 temp2 = true;
13757 }
13758 {
13759 arg3 = wxString_in_helper(obj2);
13760 if (arg3 == NULL) SWIG_fail;
13761 temp3 = true;
13762 }
13763 {
13764 arg4 = wxString_in_helper(obj3);
13765 if (arg4 == NULL) SWIG_fail;
13766 temp4 = true;
13767 }
13768 {
13769 PyThreadState* __tstate = wxPyBeginAllowThreads();
13770 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13771
13772 wxPyEndAllowThreads(__tstate);
13773 if (PyErr_Occurred()) SWIG_fail;
13774 }
13775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13776 {
13777 if (temp1)
13778 delete arg1;
13779 }
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 {
13785 if (temp3)
13786 delete arg3;
13787 }
13788 {
13789 if (temp4)
13790 delete arg4;
13791 }
13792 return resultobj;
13793 fail:
13794 {
13795 if (temp1)
13796 delete arg1;
13797 }
13798 {
13799 if (temp2)
13800 delete arg2;
13801 }
13802 {
13803 if (temp3)
13804 delete arg3;
13805 }
13806 {
13807 if (temp4)
13808 delete arg4;
13809 }
13810 return NULL;
13811 }
13812
13813
13814 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13815 PyObject *resultobj;
13816 wxArrayString *arg1 = 0 ;
13817 wxFileTypeInfo *result;
13818 bool temp1 = false ;
13819 PyObject * obj0 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "sArray", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13825 {
13826 if (! PySequence_Check(obj0)) {
13827 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13828 SWIG_fail;
13829 }
13830 arg1 = new wxArrayString;
13831 temp1 = true;
13832 int i, len=PySequence_Length(obj0);
13833 for (i=0; i<len; i++) {
13834 PyObject* item = PySequence_GetItem(obj0, i);
13835 #if wxUSE_UNICODE
13836 PyObject* str = PyObject_Unicode(item);
13837 #else
13838 PyObject* str = PyObject_Str(item);
13839 #endif
13840 if (PyErr_Occurred()) SWIG_fail;
13841 arg1->Add(Py2wxString(str));
13842 Py_DECREF(item);
13843 Py_DECREF(str);
13844 }
13845 }
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13849
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13854 {
13855 if (temp1) delete arg1;
13856 }
13857 return resultobj;
13858 fail:
13859 {
13860 if (temp1) delete arg1;
13861 }
13862 return NULL;
13863 }
13864
13865
13866 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13867 PyObject *resultobj;
13868 wxFileTypeInfo *result;
13869 char *kwnames[] = {
13870 NULL
13871 };
13872
13873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13877
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13882 return resultobj;
13883 fail:
13884 return NULL;
13885 }
13886
13887
13888 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj;
13890 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13891 bool result;
13892 PyObject * obj0 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13903
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 {
13908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13909 }
13910 return resultobj;
13911 fail:
13912 return NULL;
13913 }
13914
13915
13916 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj;
13918 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13919 wxString *arg2 = 0 ;
13920 int arg3 = (int) 0 ;
13921 bool temp2 = false ;
13922 PyObject * obj0 = 0 ;
13923 PyObject * obj1 = 0 ;
13924 PyObject * obj2 = 0 ;
13925 char *kwnames[] = {
13926 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13927 };
13928
13929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13931 if (SWIG_arg_fail(1)) SWIG_fail;
13932 {
13933 arg2 = wxString_in_helper(obj1);
13934 if (arg2 == NULL) SWIG_fail;
13935 temp2 = true;
13936 }
13937 if (obj2) {
13938 {
13939 arg3 = (int)(SWIG_As_int(obj2));
13940 if (SWIG_arg_fail(3)) SWIG_fail;
13941 }
13942 }
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13946
13947 wxPyEndAllowThreads(__tstate);
13948 if (PyErr_Occurred()) SWIG_fail;
13949 }
13950 Py_INCREF(Py_None); resultobj = Py_None;
13951 {
13952 if (temp2)
13953 delete arg2;
13954 }
13955 return resultobj;
13956 fail:
13957 {
13958 if (temp2)
13959 delete arg2;
13960 }
13961 return NULL;
13962 }
13963
13964
13965 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13968 wxString *arg2 = 0 ;
13969 bool temp2 = false ;
13970 PyObject * obj0 = 0 ;
13971 PyObject * obj1 = 0 ;
13972 char *kwnames[] = {
13973 (char *) "self",(char *) "shortDesc", NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 {
13980 arg2 = wxString_in_helper(obj1);
13981 if (arg2 == NULL) SWIG_fail;
13982 temp2 = true;
13983 }
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 (arg1)->SetShortDesc((wxString const &)*arg2);
13987
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 Py_INCREF(Py_None); resultobj = Py_None;
13992 {
13993 if (temp2)
13994 delete arg2;
13995 }
13996 return resultobj;
13997 fail:
13998 {
13999 if (temp2)
14000 delete arg2;
14001 }
14002 return NULL;
14003 }
14004
14005
14006 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj;
14008 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14009 wxString *result;
14010 PyObject * obj0 = 0 ;
14011 char *kwnames[] = {
14012 (char *) "self", NULL
14013 };
14014
14015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14017 if (SWIG_arg_fail(1)) SWIG_fail;
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 {
14021 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14022 result = (wxString *) &_result_ref;
14023 }
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 {
14029 #if wxUSE_UNICODE
14030 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14031 #else
14032 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14033 #endif
14034 }
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj;
14043 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14044 wxString *result;
14045 PyObject * obj0 = 0 ;
14046 char *kwnames[] = {
14047 (char *) "self", NULL
14048 };
14049
14050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14052 if (SWIG_arg_fail(1)) SWIG_fail;
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 {
14056 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14057 result = (wxString *) &_result_ref;
14058 }
14059
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 {
14064 #if wxUSE_UNICODE
14065 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14066 #else
14067 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14068 #endif
14069 }
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj;
14078 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14079 wxString *result;
14080 PyObject * obj0 = 0 ;
14081 char *kwnames[] = {
14082 (char *) "self", NULL
14083 };
14084
14085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 {
14089 PyThreadState* __tstate = wxPyBeginAllowThreads();
14090 {
14091 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14092 result = (wxString *) &_result_ref;
14093 }
14094
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 {
14099 #if wxUSE_UNICODE
14100 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14101 #else
14102 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14103 #endif
14104 }
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14112 PyObject *resultobj;
14113 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14114 wxString *result;
14115 PyObject * obj0 = 0 ;
14116 char *kwnames[] = {
14117 (char *) "self", NULL
14118 };
14119
14120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14122 if (SWIG_arg_fail(1)) SWIG_fail;
14123 {
14124 PyThreadState* __tstate = wxPyBeginAllowThreads();
14125 {
14126 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14127 result = (wxString *) &_result_ref;
14128 }
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 #if wxUSE_UNICODE
14135 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14136 #else
14137 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14138 #endif
14139 }
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj;
14148 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14149 wxString *result;
14150 PyObject * obj0 = 0 ;
14151 char *kwnames[] = {
14152 (char *) "self", NULL
14153 };
14154
14155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14157 if (SWIG_arg_fail(1)) SWIG_fail;
14158 {
14159 PyThreadState* __tstate = wxPyBeginAllowThreads();
14160 {
14161 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14162 result = (wxString *) &_result_ref;
14163 }
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 {
14169 #if wxUSE_UNICODE
14170 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14171 #else
14172 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14173 #endif
14174 }
14175 return resultobj;
14176 fail:
14177 return NULL;
14178 }
14179
14180
14181 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14182 PyObject *resultobj;
14183 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14184 wxArrayString *result;
14185 PyObject * obj0 = 0 ;
14186 char *kwnames[] = {
14187 (char *) "self", NULL
14188 };
14189
14190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14192 if (SWIG_arg_fail(1)) SWIG_fail;
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 {
14196 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14197 result = (wxArrayString *) &_result_ref;
14198 }
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = wxArrayString2PyList_helper(*result);
14205 }
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj;
14214 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14215 int result;
14216 PyObject * obj0 = 0 ;
14217 char *kwnames[] = {
14218 (char *) "self", NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14223 if (SWIG_arg_fail(1)) SWIG_fail;
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14227
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 resultobj = SWIG_From_int((int)(result));
14233 }
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14241 PyObject *resultobj;
14242 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14243 wxString *result;
14244 PyObject * obj0 = 0 ;
14245 char *kwnames[] = {
14246 (char *) "self", NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14251 if (SWIG_arg_fail(1)) SWIG_fail;
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 {
14255 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14256 result = (wxString *) &_result_ref;
14257 }
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 #if wxUSE_UNICODE
14264 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14265 #else
14266 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14267 #endif
14268 }
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14276 PyObject *resultobj;
14277 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14278 int result;
14279 PyObject * obj0 = 0 ;
14280 char *kwnames[] = {
14281 (char *) "self", NULL
14282 };
14283
14284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14286 if (SWIG_arg_fail(1)) SWIG_fail;
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14290
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 {
14295 resultobj = SWIG_From_int((int)(result));
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14304 PyObject *obj;
14305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14306 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14307 Py_INCREF(obj);
14308 return Py_BuildValue((char *)"");
14309 }
14310 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj;
14312 wxFileTypeInfo *arg1 = 0 ;
14313 wxFileType *result;
14314 PyObject * obj0 = 0 ;
14315 char *kwnames[] = {
14316 (char *) "ftInfo", NULL
14317 };
14318
14319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14320 {
14321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14322 if (SWIG_arg_fail(1)) SWIG_fail;
14323 if (arg1 == NULL) {
14324 SWIG_null_ref("wxFileTypeInfo");
14325 }
14326 if (SWIG_arg_fail(1)) SWIG_fail;
14327 }
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14331
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj;
14344 wxFileType *arg1 = (wxFileType *) 0 ;
14345 PyObject * obj0 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "self", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 delete arg1;
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 Py_INCREF(Py_None); resultobj = Py_None;
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj;
14369 wxFileType *arg1 = (wxFileType *) 0 ;
14370 PyObject *result;
14371 PyObject * obj0 = 0 ;
14372 char *kwnames[] = {
14373 (char *) "self", NULL
14374 };
14375
14376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14378 if (SWIG_arg_fail(1)) SWIG_fail;
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (PyObject *)wxFileType_GetMimeType(arg1);
14382
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 resultobj = result;
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj;
14395 wxFileType *arg1 = (wxFileType *) 0 ;
14396 PyObject *result;
14397 PyObject * obj0 = 0 ;
14398 char *kwnames[] = {
14399 (char *) "self", NULL
14400 };
14401
14402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14404 if (SWIG_arg_fail(1)) SWIG_fail;
14405 {
14406 PyThreadState* __tstate = wxPyBeginAllowThreads();
14407 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14408
14409 wxPyEndAllowThreads(__tstate);
14410 if (PyErr_Occurred()) SWIG_fail;
14411 }
14412 resultobj = result;
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14420 PyObject *resultobj;
14421 wxFileType *arg1 = (wxFileType *) 0 ;
14422 PyObject *result;
14423 PyObject * obj0 = 0 ;
14424 char *kwnames[] = {
14425 (char *) "self", NULL
14426 };
14427
14428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 result = (PyObject *)wxFileType_GetExtensions(arg1);
14434
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 resultobj = result;
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxFileType *arg1 = (wxFileType *) 0 ;
14448 wxIcon *result;
14449 PyObject * obj0 = 0 ;
14450 char *kwnames[] = {
14451 (char *) "self", NULL
14452 };
14453
14454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14456 if (SWIG_arg_fail(1)) SWIG_fail;
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (wxIcon *)wxFileType_GetIcon(arg1);
14460
14461 wxPyEndAllowThreads(__tstate);
14462 if (PyErr_Occurred()) SWIG_fail;
14463 }
14464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14465 return resultobj;
14466 fail:
14467 return NULL;
14468 }
14469
14470
14471 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14472 PyObject *resultobj;
14473 wxFileType *arg1 = (wxFileType *) 0 ;
14474 PyObject *result;
14475 PyObject * obj0 = 0 ;
14476 char *kwnames[] = {
14477 (char *) "self", NULL
14478 };
14479
14480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14482 if (SWIG_arg_fail(1)) SWIG_fail;
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14486
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = result;
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj;
14499 wxFileType *arg1 = (wxFileType *) 0 ;
14500 PyObject *result;
14501 PyObject * obj0 = 0 ;
14502 char *kwnames[] = {
14503 (char *) "self", NULL
14504 };
14505
14506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14508 if (SWIG_arg_fail(1)) SWIG_fail;
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (PyObject *)wxFileType_GetDescription(arg1);
14512
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 resultobj = result;
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj;
14525 wxFileType *arg1 = (wxFileType *) 0 ;
14526 wxString *arg2 = 0 ;
14527 wxString const &arg3_defvalue = wxPyEmptyString ;
14528 wxString *arg3 = (wxString *) &arg3_defvalue ;
14529 PyObject *result;
14530 bool temp2 = false ;
14531 bool temp3 = false ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 PyObject * obj2 = 0 ;
14535 char *kwnames[] = {
14536 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14537 };
14538
14539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14541 if (SWIG_arg_fail(1)) SWIG_fail;
14542 {
14543 arg2 = wxString_in_helper(obj1);
14544 if (arg2 == NULL) SWIG_fail;
14545 temp2 = true;
14546 }
14547 if (obj2) {
14548 {
14549 arg3 = wxString_in_helper(obj2);
14550 if (arg3 == NULL) SWIG_fail;
14551 temp3 = true;
14552 }
14553 }
14554 {
14555 PyThreadState* __tstate = wxPyBeginAllowThreads();
14556 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14557
14558 wxPyEndAllowThreads(__tstate);
14559 if (PyErr_Occurred()) SWIG_fail;
14560 }
14561 resultobj = result;
14562 {
14563 if (temp2)
14564 delete arg2;
14565 }
14566 {
14567 if (temp3)
14568 delete arg3;
14569 }
14570 return resultobj;
14571 fail:
14572 {
14573 if (temp2)
14574 delete arg2;
14575 }
14576 {
14577 if (temp3)
14578 delete arg3;
14579 }
14580 return NULL;
14581 }
14582
14583
14584 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14585 PyObject *resultobj;
14586 wxFileType *arg1 = (wxFileType *) 0 ;
14587 wxString *arg2 = 0 ;
14588 wxString const &arg3_defvalue = wxPyEmptyString ;
14589 wxString *arg3 = (wxString *) &arg3_defvalue ;
14590 PyObject *result;
14591 bool temp2 = false ;
14592 bool temp3 = false ;
14593 PyObject * obj0 = 0 ;
14594 PyObject * obj1 = 0 ;
14595 PyObject * obj2 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
14605 if (arg2 == NULL) SWIG_fail;
14606 temp2 = true;
14607 }
14608 if (obj2) {
14609 {
14610 arg3 = wxString_in_helper(obj2);
14611 if (arg3 == NULL) SWIG_fail;
14612 temp3 = true;
14613 }
14614 }
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14618
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 resultobj = result;
14623 {
14624 if (temp2)
14625 delete arg2;
14626 }
14627 {
14628 if (temp3)
14629 delete arg3;
14630 }
14631 return resultobj;
14632 fail:
14633 {
14634 if (temp2)
14635 delete arg2;
14636 }
14637 {
14638 if (temp3)
14639 delete arg3;
14640 }
14641 return NULL;
14642 }
14643
14644
14645 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14646 PyObject *resultobj;
14647 wxFileType *arg1 = (wxFileType *) 0 ;
14648 wxString *arg2 = 0 ;
14649 wxString const &arg3_defvalue = wxPyEmptyString ;
14650 wxString *arg3 = (wxString *) &arg3_defvalue ;
14651 PyObject *result;
14652 bool temp2 = false ;
14653 bool temp3 = false ;
14654 PyObject * obj0 = 0 ;
14655 PyObject * obj1 = 0 ;
14656 PyObject * obj2 = 0 ;
14657 char *kwnames[] = {
14658 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14659 };
14660
14661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14663 if (SWIG_arg_fail(1)) SWIG_fail;
14664 {
14665 arg2 = wxString_in_helper(obj1);
14666 if (arg2 == NULL) SWIG_fail;
14667 temp2 = true;
14668 }
14669 if (obj2) {
14670 {
14671 arg3 = wxString_in_helper(obj2);
14672 if (arg3 == NULL) SWIG_fail;
14673 temp3 = true;
14674 }
14675 }
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14679
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = result;
14684 {
14685 if (temp2)
14686 delete arg2;
14687 }
14688 {
14689 if (temp3)
14690 delete arg3;
14691 }
14692 return resultobj;
14693 fail:
14694 {
14695 if (temp2)
14696 delete arg2;
14697 }
14698 {
14699 if (temp3)
14700 delete arg3;
14701 }
14702 return NULL;
14703 }
14704
14705
14706 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14707 PyObject *resultobj;
14708 wxFileType *arg1 = (wxFileType *) 0 ;
14709 wxString *arg2 = 0 ;
14710 wxString *arg3 = 0 ;
14711 bool arg4 = (bool) true ;
14712 bool result;
14713 bool temp2 = false ;
14714 bool temp3 = false ;
14715 PyObject * obj0 = 0 ;
14716 PyObject * obj1 = 0 ;
14717 PyObject * obj2 = 0 ;
14718 PyObject * obj3 = 0 ;
14719 char *kwnames[] = {
14720 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14721 };
14722
14723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14725 if (SWIG_arg_fail(1)) SWIG_fail;
14726 {
14727 arg2 = wxString_in_helper(obj1);
14728 if (arg2 == NULL) SWIG_fail;
14729 temp2 = true;
14730 }
14731 {
14732 arg3 = wxString_in_helper(obj2);
14733 if (arg3 == NULL) SWIG_fail;
14734 temp3 = true;
14735 }
14736 if (obj3) {
14737 {
14738 arg4 = (bool)(SWIG_As_bool(obj3));
14739 if (SWIG_arg_fail(4)) SWIG_fail;
14740 }
14741 }
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14745
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 {
14750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14751 }
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 {
14757 if (temp3)
14758 delete arg3;
14759 }
14760 return resultobj;
14761 fail:
14762 {
14763 if (temp2)
14764 delete arg2;
14765 }
14766 {
14767 if (temp3)
14768 delete arg3;
14769 }
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxFileType *arg1 = (wxFileType *) 0 ;
14777 wxString const &arg2_defvalue = wxPyEmptyString ;
14778 wxString *arg2 = (wxString *) &arg2_defvalue ;
14779 int arg3 = (int) 0 ;
14780 bool result;
14781 bool temp2 = false ;
14782 PyObject * obj0 = 0 ;
14783 PyObject * obj1 = 0 ;
14784 PyObject * obj2 = 0 ;
14785 char *kwnames[] = {
14786 (char *) "self",(char *) "cmd",(char *) "index", NULL
14787 };
14788
14789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14791 if (SWIG_arg_fail(1)) SWIG_fail;
14792 if (obj1) {
14793 {
14794 arg2 = wxString_in_helper(obj1);
14795 if (arg2 == NULL) SWIG_fail;
14796 temp2 = true;
14797 }
14798 }
14799 if (obj2) {
14800 {
14801 arg3 = (int)(SWIG_As_int(obj2));
14802 if (SWIG_arg_fail(3)) SWIG_fail;
14803 }
14804 }
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 {
14813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14814 }
14815 {
14816 if (temp2)
14817 delete arg2;
14818 }
14819 return resultobj;
14820 fail:
14821 {
14822 if (temp2)
14823 delete arg2;
14824 }
14825 return NULL;
14826 }
14827
14828
14829 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj;
14831 wxFileType *arg1 = (wxFileType *) 0 ;
14832 bool result;
14833 PyObject * obj0 = 0 ;
14834 char *kwnames[] = {
14835 (char *) "self", NULL
14836 };
14837
14838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (bool)(arg1)->Unassociate();
14844
14845 wxPyEndAllowThreads(__tstate);
14846 if (PyErr_Occurred()) SWIG_fail;
14847 }
14848 {
14849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14850 }
14851 return resultobj;
14852 fail:
14853 return NULL;
14854 }
14855
14856
14857 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14858 PyObject *resultobj;
14859 wxString *arg1 = 0 ;
14860 wxString *arg2 = 0 ;
14861 wxString const &arg3_defvalue = wxPyEmptyString ;
14862 wxString *arg3 = (wxString *) &arg3_defvalue ;
14863 wxString result;
14864 bool temp1 = false ;
14865 bool temp2 = false ;
14866 bool temp3 = false ;
14867 PyObject * obj0 = 0 ;
14868 PyObject * obj1 = 0 ;
14869 PyObject * obj2 = 0 ;
14870 char *kwnames[] = {
14871 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14872 };
14873
14874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14875 {
14876 arg1 = wxString_in_helper(obj0);
14877 if (arg1 == NULL) SWIG_fail;
14878 temp1 = true;
14879 }
14880 {
14881 arg2 = wxString_in_helper(obj1);
14882 if (arg2 == NULL) SWIG_fail;
14883 temp2 = true;
14884 }
14885 if (obj2) {
14886 {
14887 arg3 = wxString_in_helper(obj2);
14888 if (arg3 == NULL) SWIG_fail;
14889 temp3 = true;
14890 }
14891 }
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14895
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 {
14900 #if wxUSE_UNICODE
14901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14902 #else
14903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14904 #endif
14905 }
14906 {
14907 if (temp1)
14908 delete arg1;
14909 }
14910 {
14911 if (temp2)
14912 delete arg2;
14913 }
14914 {
14915 if (temp3)
14916 delete arg3;
14917 }
14918 return resultobj;
14919 fail:
14920 {
14921 if (temp1)
14922 delete arg1;
14923 }
14924 {
14925 if (temp2)
14926 delete arg2;
14927 }
14928 {
14929 if (temp3)
14930 delete arg3;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14937 PyObject *obj;
14938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14939 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14940 Py_INCREF(obj);
14941 return Py_BuildValue((char *)"");
14942 }
14943 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14944 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14945 return 1;
14946 }
14947
14948
14949 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14950 PyObject *pyobj;
14951
14952 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14953 return pyobj;
14954 }
14955
14956
14957 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14958 PyObject *resultobj;
14959 wxString *arg1 = 0 ;
14960 wxString *arg2 = 0 ;
14961 bool result;
14962 bool temp1 = false ;
14963 bool temp2 = false ;
14964 PyObject * obj0 = 0 ;
14965 PyObject * obj1 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "mimeType",(char *) "wildcard", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14971 {
14972 arg1 = wxString_in_helper(obj0);
14973 if (arg1 == NULL) SWIG_fail;
14974 temp1 = true;
14975 }
14976 {
14977 arg2 = wxString_in_helper(obj1);
14978 if (arg2 == NULL) SWIG_fail;
14979 temp2 = true;
14980 }
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14990 }
14991 {
14992 if (temp1)
14993 delete arg1;
14994 }
14995 {
14996 if (temp2)
14997 delete arg2;
14998 }
14999 return resultobj;
15000 fail:
15001 {
15002 if (temp1)
15003 delete arg1;
15004 }
15005 {
15006 if (temp2)
15007 delete arg2;
15008 }
15009 return NULL;
15010 }
15011
15012
15013 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15014 PyObject *resultobj;
15015 wxMimeTypesManager *result;
15016 char *kwnames[] = {
15017 NULL
15018 };
15019
15020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15029 return resultobj;
15030 fail:
15031 return NULL;
15032 }
15033
15034
15035 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15036 PyObject *resultobj;
15037 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15038 int arg2 = (int) wxMAILCAP_ALL ;
15039 wxString const &arg3_defvalue = wxPyEmptyString ;
15040 wxString *arg3 = (wxString *) &arg3_defvalue ;
15041 bool temp3 = false ;
15042 PyObject * obj0 = 0 ;
15043 PyObject * obj1 = 0 ;
15044 PyObject * obj2 = 0 ;
15045 char *kwnames[] = {
15046 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15047 };
15048
15049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15051 if (SWIG_arg_fail(1)) SWIG_fail;
15052 if (obj1) {
15053 {
15054 arg2 = (int)(SWIG_As_int(obj1));
15055 if (SWIG_arg_fail(2)) SWIG_fail;
15056 }
15057 }
15058 if (obj2) {
15059 {
15060 arg3 = wxString_in_helper(obj2);
15061 if (arg3 == NULL) SWIG_fail;
15062 temp3 = true;
15063 }
15064 }
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 Py_INCREF(Py_None); resultobj = Py_None;
15073 {
15074 if (temp3)
15075 delete arg3;
15076 }
15077 return resultobj;
15078 fail:
15079 {
15080 if (temp3)
15081 delete arg3;
15082 }
15083 return NULL;
15084 }
15085
15086
15087 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj;
15089 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15090 PyObject * obj0 = 0 ;
15091 char *kwnames[] = {
15092 (char *) "self", NULL
15093 };
15094
15095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15097 if (SWIG_arg_fail(1)) SWIG_fail;
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 (arg1)->ClearData();
15101
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 Py_INCREF(Py_None); resultobj = Py_None;
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj;
15114 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15115 wxString *arg2 = 0 ;
15116 wxFileType *result;
15117 bool temp2 = false ;
15118 PyObject * obj0 = 0 ;
15119 PyObject * obj1 = 0 ;
15120 char *kwnames[] = {
15121 (char *) "self",(char *) "ext", NULL
15122 };
15123
15124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15126 if (SWIG_arg_fail(1)) SWIG_fail;
15127 {
15128 arg2 = wxString_in_helper(obj1);
15129 if (arg2 == NULL) SWIG_fail;
15130 temp2 = true;
15131 }
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15140 {
15141 if (temp2)
15142 delete arg2;
15143 }
15144 return resultobj;
15145 fail:
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return NULL;
15151 }
15152
15153
15154 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15155 PyObject *resultobj;
15156 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15157 wxString *arg2 = 0 ;
15158 wxFileType *result;
15159 bool temp2 = false ;
15160 PyObject * obj0 = 0 ;
15161 PyObject * obj1 = 0 ;
15162 char *kwnames[] = {
15163 (char *) "self",(char *) "mimeType", NULL
15164 };
15165
15166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15168 if (SWIG_arg_fail(1)) SWIG_fail;
15169 {
15170 arg2 = wxString_in_helper(obj1);
15171 if (arg2 == NULL) SWIG_fail;
15172 temp2 = true;
15173 }
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15177
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15182 {
15183 if (temp2)
15184 delete arg2;
15185 }
15186 return resultobj;
15187 fail:
15188 {
15189 if (temp2)
15190 delete arg2;
15191 }
15192 return NULL;
15193 }
15194
15195
15196 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj;
15198 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15199 wxString *arg2 = 0 ;
15200 bool arg3 = (bool) false ;
15201 bool result;
15202 bool temp2 = false ;
15203 PyObject * obj0 = 0 ;
15204 PyObject * obj1 = 0 ;
15205 PyObject * obj2 = 0 ;
15206 char *kwnames[] = {
15207 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15208 };
15209
15210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15212 if (SWIG_arg_fail(1)) SWIG_fail;
15213 {
15214 arg2 = wxString_in_helper(obj1);
15215 if (arg2 == NULL) SWIG_fail;
15216 temp2 = true;
15217 }
15218 if (obj2) {
15219 {
15220 arg3 = (bool)(SWIG_As_bool(obj2));
15221 if (SWIG_arg_fail(3)) SWIG_fail;
15222 }
15223 }
15224 {
15225 PyThreadState* __tstate = wxPyBeginAllowThreads();
15226 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15227
15228 wxPyEndAllowThreads(__tstate);
15229 if (PyErr_Occurred()) SWIG_fail;
15230 }
15231 {
15232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15233 }
15234 {
15235 if (temp2)
15236 delete arg2;
15237 }
15238 return resultobj;
15239 fail:
15240 {
15241 if (temp2)
15242 delete arg2;
15243 }
15244 return NULL;
15245 }
15246
15247
15248 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15249 PyObject *resultobj;
15250 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15251 wxString *arg2 = 0 ;
15252 bool result;
15253 bool temp2 = false ;
15254 PyObject * obj0 = 0 ;
15255 PyObject * obj1 = 0 ;
15256 char *kwnames[] = {
15257 (char *) "self",(char *) "filename", NULL
15258 };
15259
15260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15262 if (SWIG_arg_fail(1)) SWIG_fail;
15263 {
15264 arg2 = wxString_in_helper(obj1);
15265 if (arg2 == NULL) SWIG_fail;
15266 temp2 = true;
15267 }
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15271
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 {
15276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15277 }
15278 {
15279 if (temp2)
15280 delete arg2;
15281 }
15282 return resultobj;
15283 fail:
15284 {
15285 if (temp2)
15286 delete arg2;
15287 }
15288 return NULL;
15289 }
15290
15291
15292 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj;
15294 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15295 PyObject *result;
15296 PyObject * obj0 = 0 ;
15297 char *kwnames[] = {
15298 (char *) "self", NULL
15299 };
15300
15301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15303 if (SWIG_arg_fail(1)) SWIG_fail;
15304 {
15305 PyThreadState* __tstate = wxPyBeginAllowThreads();
15306 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15307
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = result;
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15319 PyObject *resultobj;
15320 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15321 wxFileTypeInfo *arg2 = 0 ;
15322 PyObject * obj0 = 0 ;
15323 PyObject * obj1 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self",(char *) "ft", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(2)) SWIG_fail;
15334 if (arg2 == NULL) {
15335 SWIG_null_ref("wxFileTypeInfo");
15336 }
15337 if (SWIG_arg_fail(2)) SWIG_fail;
15338 }
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15342
15343 wxPyEndAllowThreads(__tstate);
15344 if (PyErr_Occurred()) SWIG_fail;
15345 }
15346 Py_INCREF(Py_None); resultobj = Py_None;
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15354 PyObject *resultobj;
15355 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15356 wxFileTypeInfo *arg2 = 0 ;
15357 wxFileType *result;
15358 PyObject * obj0 = 0 ;
15359 PyObject * obj1 = 0 ;
15360 char *kwnames[] = {
15361 (char *) "self",(char *) "ftInfo", NULL
15362 };
15363
15364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15366 if (SWIG_arg_fail(1)) SWIG_fail;
15367 {
15368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(2)) SWIG_fail;
15370 if (arg2 == NULL) {
15371 SWIG_null_ref("wxFileTypeInfo");
15372 }
15373 if (SWIG_arg_fail(2)) SWIG_fail;
15374 }
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15378
15379 wxPyEndAllowThreads(__tstate);
15380 if (PyErr_Occurred()) SWIG_fail;
15381 }
15382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15383 return resultobj;
15384 fail:
15385 return NULL;
15386 }
15387
15388
15389 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15390 PyObject *resultobj;
15391 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15392 wxFileType *arg2 = (wxFileType *) 0 ;
15393 bool result;
15394 PyObject * obj0 = 0 ;
15395 PyObject * obj1 = 0 ;
15396 char *kwnames[] = {
15397 (char *) "self",(char *) "ft", NULL
15398 };
15399
15400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15402 if (SWIG_arg_fail(1)) SWIG_fail;
15403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15404 if (SWIG_arg_fail(2)) SWIG_fail;
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 result = (bool)(arg1)->Unassociate(arg2);
15408
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 {
15413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15414 }
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15424 PyObject * obj0 = 0 ;
15425 char *kwnames[] = {
15426 (char *) "self", NULL
15427 };
15428
15429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15431 if (SWIG_arg_fail(1)) SWIG_fail;
15432 {
15433 PyThreadState* __tstate = wxPyBeginAllowThreads();
15434 delete arg1;
15435
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 Py_INCREF(Py_None); resultobj = Py_None;
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15447 PyObject *obj;
15448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15449 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15450 Py_INCREF(obj);
15451 return Py_BuildValue((char *)"");
15452 }
15453 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15454 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15455 return 1;
15456 }
15457
15458
15459 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15460 PyObject *pyobj;
15461
15462 {
15463 #if wxUSE_UNICODE
15464 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15465 #else
15466 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15467 #endif
15468 }
15469 return pyobj;
15470 }
15471
15472
15473 static int _wrap_ART_MENU_set(PyObject *) {
15474 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15475 return 1;
15476 }
15477
15478
15479 static PyObject *_wrap_ART_MENU_get(void) {
15480 PyObject *pyobj;
15481
15482 {
15483 #if wxUSE_UNICODE
15484 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15485 #else
15486 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15487 #endif
15488 }
15489 return pyobj;
15490 }
15491
15492
15493 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15494 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15495 return 1;
15496 }
15497
15498
15499 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15500 PyObject *pyobj;
15501
15502 {
15503 #if wxUSE_UNICODE
15504 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15505 #else
15506 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15507 #endif
15508 }
15509 return pyobj;
15510 }
15511
15512
15513 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15514 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15515 return 1;
15516 }
15517
15518
15519 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15520 PyObject *pyobj;
15521
15522 {
15523 #if wxUSE_UNICODE
15524 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15525 #else
15526 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15527 #endif
15528 }
15529 return pyobj;
15530 }
15531
15532
15533 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15534 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15535 return 1;
15536 }
15537
15538
15539 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15540 PyObject *pyobj;
15541
15542 {
15543 #if wxUSE_UNICODE
15544 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15545 #else
15546 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15547 #endif
15548 }
15549 return pyobj;
15550 }
15551
15552
15553 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15554 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15555 return 1;
15556 }
15557
15558
15559 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15560 PyObject *pyobj;
15561
15562 {
15563 #if wxUSE_UNICODE
15564 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15565 #else
15566 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15567 #endif
15568 }
15569 return pyobj;
15570 }
15571
15572
15573 static int _wrap_ART_BUTTON_set(PyObject *) {
15574 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15575 return 1;
15576 }
15577
15578
15579 static PyObject *_wrap_ART_BUTTON_get(void) {
15580 PyObject *pyobj;
15581
15582 {
15583 #if wxUSE_UNICODE
15584 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15585 #else
15586 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15587 #endif
15588 }
15589 return pyobj;
15590 }
15591
15592
15593 static int _wrap_ART_OTHER_set(PyObject *) {
15594 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15595 return 1;
15596 }
15597
15598
15599 static PyObject *_wrap_ART_OTHER_get(void) {
15600 PyObject *pyobj;
15601
15602 {
15603 #if wxUSE_UNICODE
15604 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15605 #else
15606 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15607 #endif
15608 }
15609 return pyobj;
15610 }
15611
15612
15613 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15614 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15615 return 1;
15616 }
15617
15618
15619 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15620 PyObject *pyobj;
15621
15622 {
15623 #if wxUSE_UNICODE
15624 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15625 #else
15626 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15627 #endif
15628 }
15629 return pyobj;
15630 }
15631
15632
15633 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15634 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15635 return 1;
15636 }
15637
15638
15639 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15640 PyObject *pyobj;
15641
15642 {
15643 #if wxUSE_UNICODE
15644 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15645 #else
15646 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15647 #endif
15648 }
15649 return pyobj;
15650 }
15651
15652
15653 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15654 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15655 return 1;
15656 }
15657
15658
15659 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15660 PyObject *pyobj;
15661
15662 {
15663 #if wxUSE_UNICODE
15664 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15665 #else
15666 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15667 #endif
15668 }
15669 return pyobj;
15670 }
15671
15672
15673 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15674 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15675 return 1;
15676 }
15677
15678
15679 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15680 PyObject *pyobj;
15681
15682 {
15683 #if wxUSE_UNICODE
15684 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15685 #else
15686 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15687 #endif
15688 }
15689 return pyobj;
15690 }
15691
15692
15693 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15694 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15695 return 1;
15696 }
15697
15698
15699 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15700 PyObject *pyobj;
15701
15702 {
15703 #if wxUSE_UNICODE
15704 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15705 #else
15706 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15707 #endif
15708 }
15709 return pyobj;
15710 }
15711
15712
15713 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15714 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15715 return 1;
15716 }
15717
15718
15719 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15720 PyObject *pyobj;
15721
15722 {
15723 #if wxUSE_UNICODE
15724 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15725 #else
15726 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15727 #endif
15728 }
15729 return pyobj;
15730 }
15731
15732
15733 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15734 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15735 return 1;
15736 }
15737
15738
15739 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15740 PyObject *pyobj;
15741
15742 {
15743 #if wxUSE_UNICODE
15744 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15745 #else
15746 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15747 #endif
15748 }
15749 return pyobj;
15750 }
15751
15752
15753 static int _wrap_ART_GO_BACK_set(PyObject *) {
15754 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15755 return 1;
15756 }
15757
15758
15759 static PyObject *_wrap_ART_GO_BACK_get(void) {
15760 PyObject *pyobj;
15761
15762 {
15763 #if wxUSE_UNICODE
15764 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15765 #else
15766 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15767 #endif
15768 }
15769 return pyobj;
15770 }
15771
15772
15773 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15774 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15775 return 1;
15776 }
15777
15778
15779 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15780 PyObject *pyobj;
15781
15782 {
15783 #if wxUSE_UNICODE
15784 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15785 #else
15786 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15787 #endif
15788 }
15789 return pyobj;
15790 }
15791
15792
15793 static int _wrap_ART_GO_UP_set(PyObject *) {
15794 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15795 return 1;
15796 }
15797
15798
15799 static PyObject *_wrap_ART_GO_UP_get(void) {
15800 PyObject *pyobj;
15801
15802 {
15803 #if wxUSE_UNICODE
15804 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15805 #else
15806 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15807 #endif
15808 }
15809 return pyobj;
15810 }
15811
15812
15813 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15814 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15815 return 1;
15816 }
15817
15818
15819 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15820 PyObject *pyobj;
15821
15822 {
15823 #if wxUSE_UNICODE
15824 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15825 #else
15826 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15827 #endif
15828 }
15829 return pyobj;
15830 }
15831
15832
15833 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15834 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15835 return 1;
15836 }
15837
15838
15839 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15840 PyObject *pyobj;
15841
15842 {
15843 #if wxUSE_UNICODE
15844 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15845 #else
15846 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15847 #endif
15848 }
15849 return pyobj;
15850 }
15851
15852
15853 static int _wrap_ART_GO_HOME_set(PyObject *) {
15854 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15855 return 1;
15856 }
15857
15858
15859 static PyObject *_wrap_ART_GO_HOME_get(void) {
15860 PyObject *pyobj;
15861
15862 {
15863 #if wxUSE_UNICODE
15864 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15865 #else
15866 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15867 #endif
15868 }
15869 return pyobj;
15870 }
15871
15872
15873 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15874 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15875 return 1;
15876 }
15877
15878
15879 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15880 PyObject *pyobj;
15881
15882 {
15883 #if wxUSE_UNICODE
15884 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15885 #else
15886 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15887 #endif
15888 }
15889 return pyobj;
15890 }
15891
15892
15893 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15894 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15895 return 1;
15896 }
15897
15898
15899 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15900 PyObject *pyobj;
15901
15902 {
15903 #if wxUSE_UNICODE
15904 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15905 #else
15906 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15907 #endif
15908 }
15909 return pyobj;
15910 }
15911
15912
15913 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15914 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15915 return 1;
15916 }
15917
15918
15919 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15920 PyObject *pyobj;
15921
15922 {
15923 #if wxUSE_UNICODE
15924 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15925 #else
15926 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15927 #endif
15928 }
15929 return pyobj;
15930 }
15931
15932
15933 static int _wrap_ART_PRINT_set(PyObject *) {
15934 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15935 return 1;
15936 }
15937
15938
15939 static PyObject *_wrap_ART_PRINT_get(void) {
15940 PyObject *pyobj;
15941
15942 {
15943 #if wxUSE_UNICODE
15944 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15945 #else
15946 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15947 #endif
15948 }
15949 return pyobj;
15950 }
15951
15952
15953 static int _wrap_ART_HELP_set(PyObject *) {
15954 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15955 return 1;
15956 }
15957
15958
15959 static PyObject *_wrap_ART_HELP_get(void) {
15960 PyObject *pyobj;
15961
15962 {
15963 #if wxUSE_UNICODE
15964 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15965 #else
15966 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15967 #endif
15968 }
15969 return pyobj;
15970 }
15971
15972
15973 static int _wrap_ART_TIP_set(PyObject *) {
15974 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15975 return 1;
15976 }
15977
15978
15979 static PyObject *_wrap_ART_TIP_get(void) {
15980 PyObject *pyobj;
15981
15982 {
15983 #if wxUSE_UNICODE
15984 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15985 #else
15986 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15987 #endif
15988 }
15989 return pyobj;
15990 }
15991
15992
15993 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15994 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15995 return 1;
15996 }
15997
15998
15999 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16000 PyObject *pyobj;
16001
16002 {
16003 #if wxUSE_UNICODE
16004 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16005 #else
16006 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16007 #endif
16008 }
16009 return pyobj;
16010 }
16011
16012
16013 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16014 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16015 return 1;
16016 }
16017
16018
16019 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16020 PyObject *pyobj;
16021
16022 {
16023 #if wxUSE_UNICODE
16024 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16025 #else
16026 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16027 #endif
16028 }
16029 return pyobj;
16030 }
16031
16032
16033 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16034 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16035 return 1;
16036 }
16037
16038
16039 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16040 PyObject *pyobj;
16041
16042 {
16043 #if wxUSE_UNICODE
16044 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16045 #else
16046 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16047 #endif
16048 }
16049 return pyobj;
16050 }
16051
16052
16053 static int _wrap_ART_HARDDISK_set(PyObject *) {
16054 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16055 return 1;
16056 }
16057
16058
16059 static PyObject *_wrap_ART_HARDDISK_get(void) {
16060 PyObject *pyobj;
16061
16062 {
16063 #if wxUSE_UNICODE
16064 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16065 #else
16066 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16067 #endif
16068 }
16069 return pyobj;
16070 }
16071
16072
16073 static int _wrap_ART_FLOPPY_set(PyObject *) {
16074 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16075 return 1;
16076 }
16077
16078
16079 static PyObject *_wrap_ART_FLOPPY_get(void) {
16080 PyObject *pyobj;
16081
16082 {
16083 #if wxUSE_UNICODE
16084 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16085 #else
16086 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16087 #endif
16088 }
16089 return pyobj;
16090 }
16091
16092
16093 static int _wrap_ART_CDROM_set(PyObject *) {
16094 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16095 return 1;
16096 }
16097
16098
16099 static PyObject *_wrap_ART_CDROM_get(void) {
16100 PyObject *pyobj;
16101
16102 {
16103 #if wxUSE_UNICODE
16104 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16105 #else
16106 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16107 #endif
16108 }
16109 return pyobj;
16110 }
16111
16112
16113 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16114 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16115 return 1;
16116 }
16117
16118
16119 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16120 PyObject *pyobj;
16121
16122 {
16123 #if wxUSE_UNICODE
16124 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16125 #else
16126 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16127 #endif
16128 }
16129 return pyobj;
16130 }
16131
16132
16133 static int _wrap_ART_FOLDER_set(PyObject *) {
16134 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16135 return 1;
16136 }
16137
16138
16139 static PyObject *_wrap_ART_FOLDER_get(void) {
16140 PyObject *pyobj;
16141
16142 {
16143 #if wxUSE_UNICODE
16144 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16145 #else
16146 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16147 #endif
16148 }
16149 return pyobj;
16150 }
16151
16152
16153 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16154 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16155 return 1;
16156 }
16157
16158
16159 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16160 PyObject *pyobj;
16161
16162 {
16163 #if wxUSE_UNICODE
16164 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16165 #else
16166 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16167 #endif
16168 }
16169 return pyobj;
16170 }
16171
16172
16173 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16174 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16175 return 1;
16176 }
16177
16178
16179 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16180 PyObject *pyobj;
16181
16182 {
16183 #if wxUSE_UNICODE
16184 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16185 #else
16186 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16187 #endif
16188 }
16189 return pyobj;
16190 }
16191
16192
16193 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16194 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16195 return 1;
16196 }
16197
16198
16199 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16200 PyObject *pyobj;
16201
16202 {
16203 #if wxUSE_UNICODE
16204 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16205 #else
16206 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16207 #endif
16208 }
16209 return pyobj;
16210 }
16211
16212
16213 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16214 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16215 return 1;
16216 }
16217
16218
16219 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16220 PyObject *pyobj;
16221
16222 {
16223 #if wxUSE_UNICODE
16224 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16225 #else
16226 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16227 #endif
16228 }
16229 return pyobj;
16230 }
16231
16232
16233 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16234 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16235 return 1;
16236 }
16237
16238
16239 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16240 PyObject *pyobj;
16241
16242 {
16243 #if wxUSE_UNICODE
16244 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16245 #else
16246 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16247 #endif
16248 }
16249 return pyobj;
16250 }
16251
16252
16253 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16254 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16255 return 1;
16256 }
16257
16258
16259 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16260 PyObject *pyobj;
16261
16262 {
16263 #if wxUSE_UNICODE
16264 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16265 #else
16266 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16267 #endif
16268 }
16269 return pyobj;
16270 }
16271
16272
16273 static int _wrap_ART_ERROR_set(PyObject *) {
16274 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16275 return 1;
16276 }
16277
16278
16279 static PyObject *_wrap_ART_ERROR_get(void) {
16280 PyObject *pyobj;
16281
16282 {
16283 #if wxUSE_UNICODE
16284 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16285 #else
16286 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16287 #endif
16288 }
16289 return pyobj;
16290 }
16291
16292
16293 static int _wrap_ART_QUESTION_set(PyObject *) {
16294 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16295 return 1;
16296 }
16297
16298
16299 static PyObject *_wrap_ART_QUESTION_get(void) {
16300 PyObject *pyobj;
16301
16302 {
16303 #if wxUSE_UNICODE
16304 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16305 #else
16306 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16307 #endif
16308 }
16309 return pyobj;
16310 }
16311
16312
16313 static int _wrap_ART_WARNING_set(PyObject *) {
16314 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16315 return 1;
16316 }
16317
16318
16319 static PyObject *_wrap_ART_WARNING_get(void) {
16320 PyObject *pyobj;
16321
16322 {
16323 #if wxUSE_UNICODE
16324 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16325 #else
16326 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16327 #endif
16328 }
16329 return pyobj;
16330 }
16331
16332
16333 static int _wrap_ART_INFORMATION_set(PyObject *) {
16334 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16335 return 1;
16336 }
16337
16338
16339 static PyObject *_wrap_ART_INFORMATION_get(void) {
16340 PyObject *pyobj;
16341
16342 {
16343 #if wxUSE_UNICODE
16344 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16345 #else
16346 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16347 #endif
16348 }
16349 return pyobj;
16350 }
16351
16352
16353 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16354 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16355 return 1;
16356 }
16357
16358
16359 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16360 PyObject *pyobj;
16361
16362 {
16363 #if wxUSE_UNICODE
16364 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16365 #else
16366 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16367 #endif
16368 }
16369 return pyobj;
16370 }
16371
16372
16373 static int _wrap_ART_COPY_set(PyObject *) {
16374 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16375 return 1;
16376 }
16377
16378
16379 static PyObject *_wrap_ART_COPY_get(void) {
16380 PyObject *pyobj;
16381
16382 {
16383 #if wxUSE_UNICODE
16384 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16385 #else
16386 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16387 #endif
16388 }
16389 return pyobj;
16390 }
16391
16392
16393 static int _wrap_ART_CUT_set(PyObject *) {
16394 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16395 return 1;
16396 }
16397
16398
16399 static PyObject *_wrap_ART_CUT_get(void) {
16400 PyObject *pyobj;
16401
16402 {
16403 #if wxUSE_UNICODE
16404 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16405 #else
16406 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16407 #endif
16408 }
16409 return pyobj;
16410 }
16411
16412
16413 static int _wrap_ART_PASTE_set(PyObject *) {
16414 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16415 return 1;
16416 }
16417
16418
16419 static PyObject *_wrap_ART_PASTE_get(void) {
16420 PyObject *pyobj;
16421
16422 {
16423 #if wxUSE_UNICODE
16424 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16425 #else
16426 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16427 #endif
16428 }
16429 return pyobj;
16430 }
16431
16432
16433 static int _wrap_ART_DELETE_set(PyObject *) {
16434 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16435 return 1;
16436 }
16437
16438
16439 static PyObject *_wrap_ART_DELETE_get(void) {
16440 PyObject *pyobj;
16441
16442 {
16443 #if wxUSE_UNICODE
16444 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16445 #else
16446 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16447 #endif
16448 }
16449 return pyobj;
16450 }
16451
16452
16453 static int _wrap_ART_UNDO_set(PyObject *) {
16454 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16455 return 1;
16456 }
16457
16458
16459 static PyObject *_wrap_ART_UNDO_get(void) {
16460 PyObject *pyobj;
16461
16462 {
16463 #if wxUSE_UNICODE
16464 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16465 #else
16466 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16467 #endif
16468 }
16469 return pyobj;
16470 }
16471
16472
16473 static int _wrap_ART_REDO_set(PyObject *) {
16474 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16475 return 1;
16476 }
16477
16478
16479 static PyObject *_wrap_ART_REDO_get(void) {
16480 PyObject *pyobj;
16481
16482 {
16483 #if wxUSE_UNICODE
16484 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16485 #else
16486 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16487 #endif
16488 }
16489 return pyobj;
16490 }
16491
16492
16493 static int _wrap_ART_QUIT_set(PyObject *) {
16494 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16495 return 1;
16496 }
16497
16498
16499 static PyObject *_wrap_ART_QUIT_get(void) {
16500 PyObject *pyobj;
16501
16502 {
16503 #if wxUSE_UNICODE
16504 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16505 #else
16506 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16507 #endif
16508 }
16509 return pyobj;
16510 }
16511
16512
16513 static int _wrap_ART_FIND_set(PyObject *) {
16514 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16515 return 1;
16516 }
16517
16518
16519 static PyObject *_wrap_ART_FIND_get(void) {
16520 PyObject *pyobj;
16521
16522 {
16523 #if wxUSE_UNICODE
16524 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16525 #else
16526 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16527 #endif
16528 }
16529 return pyobj;
16530 }
16531
16532
16533 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16534 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16535 return 1;
16536 }
16537
16538
16539 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16540 PyObject *pyobj;
16541
16542 {
16543 #if wxUSE_UNICODE
16544 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16545 #else
16546 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16547 #endif
16548 }
16549 return pyobj;
16550 }
16551
16552
16553 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 wxPyArtProvider *result;
16556 char *kwnames[] = {
16557 NULL
16558 };
16559
16560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16561 {
16562 if (!wxPyCheckForApp()) SWIG_fail;
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (wxPyArtProvider *)new wxPyArtProvider();
16565
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16570 return resultobj;
16571 fail:
16572 return NULL;
16573 }
16574
16575
16576 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16577 PyObject *resultobj;
16578 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16579 PyObject *arg2 = (PyObject *) 0 ;
16580 PyObject *arg3 = (PyObject *) 0 ;
16581 PyObject * obj0 = 0 ;
16582 PyObject * obj1 = 0 ;
16583 PyObject * obj2 = 0 ;
16584 char *kwnames[] = {
16585 (char *) "self",(char *) "self",(char *) "_class", NULL
16586 };
16587
16588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16590 if (SWIG_arg_fail(1)) SWIG_fail;
16591 arg2 = obj1;
16592 arg3 = obj2;
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 (arg1)->_setCallbackInfo(arg2,arg3);
16596
16597 wxPyEndAllowThreads(__tstate);
16598 if (PyErr_Occurred()) SWIG_fail;
16599 }
16600 Py_INCREF(Py_None); resultobj = Py_None;
16601 return resultobj;
16602 fail:
16603 return NULL;
16604 }
16605
16606
16607 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16608 PyObject *resultobj;
16609 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16610 PyObject * obj0 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "provider", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 wxPyArtProvider::PushProvider(arg1);
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 Py_INCREF(Py_None); resultobj = Py_None;
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 bool result;
16635 char *kwnames[] = {
16636 NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 result = (bool)wxPyArtProvider::PopProvider();
16643
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 {
16648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16649 }
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16657 PyObject *resultobj;
16658 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16659 bool result;
16660 PyObject * obj0 = 0 ;
16661 char *kwnames[] = {
16662 (char *) "provider", NULL
16663 };
16664
16665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16667 if (SWIG_arg_fail(1)) SWIG_fail;
16668 {
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16671
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 {
16676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16677 }
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj;
16686 wxString *arg1 = 0 ;
16687 wxString const &arg2_defvalue = wxPyART_OTHER ;
16688 wxString *arg2 = (wxString *) &arg2_defvalue ;
16689 wxSize const &arg3_defvalue = wxDefaultSize ;
16690 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16691 wxBitmap result;
16692 bool temp1 = false ;
16693 bool temp2 = false ;
16694 wxSize temp3 ;
16695 PyObject * obj0 = 0 ;
16696 PyObject * obj1 = 0 ;
16697 PyObject * obj2 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "id",(char *) "client",(char *) "size", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16703 {
16704 arg1 = wxString_in_helper(obj0);
16705 if (arg1 == NULL) SWIG_fail;
16706 temp1 = true;
16707 }
16708 if (obj1) {
16709 {
16710 arg2 = wxString_in_helper(obj1);
16711 if (arg2 == NULL) SWIG_fail;
16712 temp2 = true;
16713 }
16714 }
16715 if (obj2) {
16716 {
16717 arg3 = &temp3;
16718 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16719 }
16720 }
16721 {
16722 if (!wxPyCheckForApp()) SWIG_fail;
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16725
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 {
16730 wxBitmap * resultptr;
16731 resultptr = new wxBitmap((wxBitmap &)(result));
16732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16733 }
16734 {
16735 if (temp1)
16736 delete arg1;
16737 }
16738 {
16739 if (temp2)
16740 delete arg2;
16741 }
16742 return resultobj;
16743 fail:
16744 {
16745 if (temp1)
16746 delete arg1;
16747 }
16748 {
16749 if (temp2)
16750 delete arg2;
16751 }
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxString *arg1 = 0 ;
16759 wxString const &arg2_defvalue = wxPyART_OTHER ;
16760 wxString *arg2 = (wxString *) &arg2_defvalue ;
16761 wxSize const &arg3_defvalue = wxDefaultSize ;
16762 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16763 wxIcon result;
16764 bool temp1 = false ;
16765 bool temp2 = false ;
16766 wxSize temp3 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 PyObject * obj2 = 0 ;
16770 char *kwnames[] = {
16771 (char *) "id",(char *) "client",(char *) "size", NULL
16772 };
16773
16774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16775 {
16776 arg1 = wxString_in_helper(obj0);
16777 if (arg1 == NULL) SWIG_fail;
16778 temp1 = true;
16779 }
16780 if (obj1) {
16781 {
16782 arg2 = wxString_in_helper(obj1);
16783 if (arg2 == NULL) SWIG_fail;
16784 temp2 = true;
16785 }
16786 }
16787 if (obj2) {
16788 {
16789 arg3 = &temp3;
16790 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16791 }
16792 }
16793 {
16794 if (!wxPyCheckForApp()) SWIG_fail;
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 wxIcon * resultptr;
16803 resultptr = new wxIcon((wxIcon &)(result));
16804 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16805 }
16806 {
16807 if (temp1)
16808 delete arg1;
16809 }
16810 {
16811 if (temp2)
16812 delete arg2;
16813 }
16814 return resultobj;
16815 fail:
16816 {
16817 if (temp1)
16818 delete arg1;
16819 }
16820 {
16821 if (temp2)
16822 delete arg2;
16823 }
16824 return NULL;
16825 }
16826
16827
16828 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16829 PyObject *resultobj;
16830 wxString *arg1 = 0 ;
16831 bool arg2 = (bool) false ;
16832 wxSize result;
16833 bool temp1 = false ;
16834 PyObject * obj0 = 0 ;
16835 PyObject * obj1 = 0 ;
16836 char *kwnames[] = {
16837 (char *) "client",(char *) "platform_dependent", NULL
16838 };
16839
16840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16841 {
16842 arg1 = wxString_in_helper(obj0);
16843 if (arg1 == NULL) SWIG_fail;
16844 temp1 = true;
16845 }
16846 if (obj1) {
16847 {
16848 arg2 = (bool)(SWIG_As_bool(obj1));
16849 if (SWIG_arg_fail(2)) SWIG_fail;
16850 }
16851 }
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 {
16860 wxSize * resultptr;
16861 resultptr = new wxSize((wxSize &)(result));
16862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16863 }
16864 {
16865 if (temp1)
16866 delete arg1;
16867 }
16868 return resultobj;
16869 fail:
16870 {
16871 if (temp1)
16872 delete arg1;
16873 }
16874 return NULL;
16875 }
16876
16877
16878 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj;
16880 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16881 PyObject * obj0 = 0 ;
16882 char *kwnames[] = {
16883 (char *) "self", NULL
16884 };
16885
16886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16888 if (SWIG_arg_fail(1)) SWIG_fail;
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 wxPyArtProvider_Destroy(arg1);
16892
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 Py_INCREF(Py_None); resultobj = Py_None;
16897 return resultobj;
16898 fail:
16899 return NULL;
16900 }
16901
16902
16903 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16904 PyObject *obj;
16905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16906 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16907 Py_INCREF(obj);
16908 return Py_BuildValue((char *)"");
16909 }
16910 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj;
16912 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16913 PyObject * obj0 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 delete arg1;
16924
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 Py_INCREF(Py_None); resultobj = Py_None;
16929 return resultobj;
16930 fail:
16931 return NULL;
16932 }
16933
16934
16935 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16936 PyObject *resultobj;
16937 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16938 wxConfigBase *result;
16939 PyObject * obj0 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "config", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 PyThreadState* __tstate = wxPyBeginAllowThreads();
16949 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16950
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16962 PyObject *resultobj;
16963 bool arg1 = (bool) true ;
16964 wxConfigBase *result;
16965 PyObject * obj0 = 0 ;
16966 char *kwnames[] = {
16967 (char *) "createOnDemand", NULL
16968 };
16969
16970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16971 if (obj0) {
16972 {
16973 arg1 = (bool)(SWIG_As_bool(obj0));
16974 if (SWIG_arg_fail(1)) SWIG_fail;
16975 }
16976 }
16977 {
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16980
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16985 return resultobj;
16986 fail:
16987 return NULL;
16988 }
16989
16990
16991 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj;
16993 wxConfigBase *result;
16994 char *kwnames[] = {
16995 NULL
16996 };
16997
16998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = (wxConfigBase *)wxConfigBase::Create();
17002
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 char *kwnames[] = {
17016 NULL
17017 };
17018
17019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 wxConfigBase::DontCreateOnDemand();
17023
17024 wxPyEndAllowThreads(__tstate);
17025 if (PyErr_Occurred()) SWIG_fail;
17026 }
17027 Py_INCREF(Py_None); resultobj = Py_None;
17028 return resultobj;
17029 fail:
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17037 wxString *arg2 = 0 ;
17038 bool temp2 = false ;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 char *kwnames[] = {
17042 (char *) "self",(char *) "path", NULL
17043 };
17044
17045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) 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 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 (arg1)->SetPath((wxString const &)*arg2);
17056
17057 wxPyEndAllowThreads(__tstate);
17058 if (PyErr_Occurred()) SWIG_fail;
17059 }
17060 Py_INCREF(Py_None); resultobj = Py_None;
17061 {
17062 if (temp2)
17063 delete arg2;
17064 }
17065 return resultobj;
17066 fail:
17067 {
17068 if (temp2)
17069 delete arg2;
17070 }
17071 return NULL;
17072 }
17073
17074
17075 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17076 PyObject *resultobj;
17077 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17078 wxString *result;
17079 PyObject * obj0 = 0 ;
17080 char *kwnames[] = {
17081 (char *) "self", NULL
17082 };
17083
17084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17086 if (SWIG_arg_fail(1)) SWIG_fail;
17087 {
17088 PyThreadState* __tstate = wxPyBeginAllowThreads();
17089 {
17090 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17091 result = (wxString *) &_result_ref;
17092 }
17093
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 {
17098 #if wxUSE_UNICODE
17099 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17100 #else
17101 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17102 #endif
17103 }
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17111 PyObject *resultobj;
17112 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17113 PyObject *result;
17114 PyObject * obj0 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "self", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17121 if (SWIG_arg_fail(1)) SWIG_fail;
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17125
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 resultobj = result;
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj;
17138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17139 long arg2 ;
17140 PyObject *result;
17141 PyObject * obj0 = 0 ;
17142 PyObject * obj1 = 0 ;
17143 char *kwnames[] = {
17144 (char *) "self",(char *) "index", NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17149 if (SWIG_arg_fail(1)) SWIG_fail;
17150 {
17151 arg2 = (long)(SWIG_As_long(obj1));
17152 if (SWIG_arg_fail(2)) SWIG_fail;
17153 }
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 resultobj = result;
17162 return resultobj;
17163 fail:
17164 return NULL;
17165 }
17166
17167
17168 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj;
17170 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17171 PyObject *result;
17172 PyObject * obj0 = 0 ;
17173 char *kwnames[] = {
17174 (char *) "self", NULL
17175 };
17176
17177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17179 if (SWIG_arg_fail(1)) SWIG_fail;
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17183
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = result;
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17197 long arg2 ;
17198 PyObject *result;
17199 PyObject * obj0 = 0 ;
17200 PyObject * obj1 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "self",(char *) "index", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17207 if (SWIG_arg_fail(1)) SWIG_fail;
17208 {
17209 arg2 = (long)(SWIG_As_long(obj1));
17210 if (SWIG_arg_fail(2)) SWIG_fail;
17211 }
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17215
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 resultobj = result;
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17229 bool arg2 = (bool) false ;
17230 size_t result;
17231 PyObject * obj0 = 0 ;
17232 PyObject * obj1 = 0 ;
17233 char *kwnames[] = {
17234 (char *) "self",(char *) "recursive", NULL
17235 };
17236
17237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(1)) SWIG_fail;
17240 if (obj1) {
17241 {
17242 arg2 = (bool)(SWIG_As_bool(obj1));
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 }
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17249
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 {
17254 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17255 }
17256 return resultobj;
17257 fail:
17258 return NULL;
17259 }
17260
17261
17262 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj;
17264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17265 bool arg2 = (bool) false ;
17266 size_t result;
17267 PyObject * obj0 = 0 ;
17268 PyObject * obj1 = 0 ;
17269 char *kwnames[] = {
17270 (char *) "self",(char *) "recursive", NULL
17271 };
17272
17273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17275 if (SWIG_arg_fail(1)) SWIG_fail;
17276 if (obj1) {
17277 {
17278 arg2 = (bool)(SWIG_As_bool(obj1));
17279 if (SWIG_arg_fail(2)) SWIG_fail;
17280 }
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 {
17290 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17291 }
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17301 wxString *arg2 = 0 ;
17302 bool result;
17303 bool temp2 = false ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self",(char *) "name", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 {
17314 arg2 = wxString_in_helper(obj1);
17315 if (arg2 == NULL) SWIG_fail;
17316 temp2 = true;
17317 }
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17321
17322 wxPyEndAllowThreads(__tstate);
17323 if (PyErr_Occurred()) SWIG_fail;
17324 }
17325 {
17326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17327 }
17328 {
17329 if (temp2)
17330 delete arg2;
17331 }
17332 return resultobj;
17333 fail:
17334 {
17335 if (temp2)
17336 delete arg2;
17337 }
17338 return NULL;
17339 }
17340
17341
17342 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17343 PyObject *resultobj;
17344 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17345 wxString *arg2 = 0 ;
17346 bool result;
17347 bool temp2 = false ;
17348 PyObject * obj0 = 0 ;
17349 PyObject * obj1 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self",(char *) "name", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 {
17358 arg2 = wxString_in_helper(obj1);
17359 if (arg2 == NULL) SWIG_fail;
17360 temp2 = true;
17361 }
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17365
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 {
17370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17371 }
17372 {
17373 if (temp2)
17374 delete arg2;
17375 }
17376 return resultobj;
17377 fail:
17378 {
17379 if (temp2)
17380 delete arg2;
17381 }
17382 return NULL;
17383 }
17384
17385
17386 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17387 PyObject *resultobj;
17388 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17389 wxString *arg2 = 0 ;
17390 bool result;
17391 bool temp2 = false ;
17392 PyObject * obj0 = 0 ;
17393 PyObject * obj1 = 0 ;
17394 char *kwnames[] = {
17395 (char *) "self",(char *) "name", NULL
17396 };
17397
17398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17400 if (SWIG_arg_fail(1)) SWIG_fail;
17401 {
17402 arg2 = wxString_in_helper(obj1);
17403 if (arg2 == NULL) SWIG_fail;
17404 temp2 = true;
17405 }
17406 {
17407 PyThreadState* __tstate = wxPyBeginAllowThreads();
17408 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17409
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 {
17414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17415 }
17416 {
17417 if (temp2)
17418 delete arg2;
17419 }
17420 return resultobj;
17421 fail:
17422 {
17423 if (temp2)
17424 delete arg2;
17425 }
17426 return NULL;
17427 }
17428
17429
17430 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17431 PyObject *resultobj;
17432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17433 wxString *arg2 = 0 ;
17434 wxConfigBase::EntryType result;
17435 bool temp2 = false ;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "self",(char *) "name", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17444 if (SWIG_arg_fail(1)) SWIG_fail;
17445 {
17446 arg2 = wxString_in_helper(obj1);
17447 if (arg2 == NULL) SWIG_fail;
17448 temp2 = true;
17449 }
17450 {
17451 PyThreadState* __tstate = wxPyBeginAllowThreads();
17452 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17453
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 resultobj = SWIG_From_int((result));
17458 {
17459 if (temp2)
17460 delete arg2;
17461 }
17462 return resultobj;
17463 fail:
17464 {
17465 if (temp2)
17466 delete arg2;
17467 }
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17475 wxString *arg2 = 0 ;
17476 wxString const &arg3_defvalue = wxPyEmptyString ;
17477 wxString *arg3 = (wxString *) &arg3_defvalue ;
17478 wxString result;
17479 bool temp2 = false ;
17480 bool temp3 = false ;
17481 PyObject * obj0 = 0 ;
17482 PyObject * obj1 = 0 ;
17483 PyObject * obj2 = 0 ;
17484 char *kwnames[] = {
17485 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17486 };
17487
17488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17490 if (SWIG_arg_fail(1)) SWIG_fail;
17491 {
17492 arg2 = wxString_in_helper(obj1);
17493 if (arg2 == NULL) SWIG_fail;
17494 temp2 = true;
17495 }
17496 if (obj2) {
17497 {
17498 arg3 = wxString_in_helper(obj2);
17499 if (arg3 == NULL) SWIG_fail;
17500 temp3 = true;
17501 }
17502 }
17503 {
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17506
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 {
17511 #if wxUSE_UNICODE
17512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17513 #else
17514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17515 #endif
17516 }
17517 {
17518 if (temp2)
17519 delete arg2;
17520 }
17521 {
17522 if (temp3)
17523 delete arg3;
17524 }
17525 return resultobj;
17526 fail:
17527 {
17528 if (temp2)
17529 delete arg2;
17530 }
17531 {
17532 if (temp3)
17533 delete arg3;
17534 }
17535 return NULL;
17536 }
17537
17538
17539 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17540 PyObject *resultobj;
17541 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17542 wxString *arg2 = 0 ;
17543 long arg3 = (long) 0 ;
17544 long result;
17545 bool temp2 = false ;
17546 PyObject * obj0 = 0 ;
17547 PyObject * obj1 = 0 ;
17548 PyObject * obj2 = 0 ;
17549 char *kwnames[] = {
17550 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17551 };
17552
17553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17555 if (SWIG_arg_fail(1)) SWIG_fail;
17556 {
17557 arg2 = wxString_in_helper(obj1);
17558 if (arg2 == NULL) SWIG_fail;
17559 temp2 = true;
17560 }
17561 if (obj2) {
17562 {
17563 arg3 = (long)(SWIG_As_long(obj2));
17564 if (SWIG_arg_fail(3)) SWIG_fail;
17565 }
17566 }
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17570
17571 wxPyEndAllowThreads(__tstate);
17572 if (PyErr_Occurred()) SWIG_fail;
17573 }
17574 {
17575 resultobj = SWIG_From_long((long)(result));
17576 }
17577 {
17578 if (temp2)
17579 delete arg2;
17580 }
17581 return resultobj;
17582 fail:
17583 {
17584 if (temp2)
17585 delete arg2;
17586 }
17587 return NULL;
17588 }
17589
17590
17591 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17592 PyObject *resultobj;
17593 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17594 wxString *arg2 = 0 ;
17595 double arg3 = (double) 0.0 ;
17596 double result;
17597 bool temp2 = false ;
17598 PyObject * obj0 = 0 ;
17599 PyObject * obj1 = 0 ;
17600 PyObject * obj2 = 0 ;
17601 char *kwnames[] = {
17602 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17603 };
17604
17605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17607 if (SWIG_arg_fail(1)) SWIG_fail;
17608 {
17609 arg2 = wxString_in_helper(obj1);
17610 if (arg2 == NULL) SWIG_fail;
17611 temp2 = true;
17612 }
17613 if (obj2) {
17614 {
17615 arg3 = (double)(SWIG_As_double(obj2));
17616 if (SWIG_arg_fail(3)) SWIG_fail;
17617 }
17618 }
17619 {
17620 PyThreadState* __tstate = wxPyBeginAllowThreads();
17621 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17622
17623 wxPyEndAllowThreads(__tstate);
17624 if (PyErr_Occurred()) SWIG_fail;
17625 }
17626 {
17627 resultobj = SWIG_From_double((double)(result));
17628 }
17629 {
17630 if (temp2)
17631 delete arg2;
17632 }
17633 return resultobj;
17634 fail:
17635 {
17636 if (temp2)
17637 delete arg2;
17638 }
17639 return NULL;
17640 }
17641
17642
17643 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17644 PyObject *resultobj;
17645 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17646 wxString *arg2 = 0 ;
17647 bool arg3 = (bool) false ;
17648 bool result;
17649 bool temp2 = false ;
17650 PyObject * obj0 = 0 ;
17651 PyObject * obj1 = 0 ;
17652 PyObject * obj2 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 {
17661 arg2 = wxString_in_helper(obj1);
17662 if (arg2 == NULL) SWIG_fail;
17663 temp2 = true;
17664 }
17665 if (obj2) {
17666 {
17667 arg3 = (bool)(SWIG_As_bool(obj2));
17668 if (SWIG_arg_fail(3)) SWIG_fail;
17669 }
17670 }
17671 {
17672 PyThreadState* __tstate = wxPyBeginAllowThreads();
17673 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17674
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17680 }
17681 {
17682 if (temp2)
17683 delete arg2;
17684 }
17685 return resultobj;
17686 fail:
17687 {
17688 if (temp2)
17689 delete arg2;
17690 }
17691 return NULL;
17692 }
17693
17694
17695 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17696 PyObject *resultobj;
17697 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17698 wxString *arg2 = 0 ;
17699 wxString *arg3 = 0 ;
17700 bool result;
17701 bool temp2 = false ;
17702 bool temp3 = false ;
17703 PyObject * obj0 = 0 ;
17704 PyObject * obj1 = 0 ;
17705 PyObject * obj2 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self",(char *) "key",(char *) "value", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 {
17714 arg2 = wxString_in_helper(obj1);
17715 if (arg2 == NULL) SWIG_fail;
17716 temp2 = true;
17717 }
17718 {
17719 arg3 = wxString_in_helper(obj2);
17720 if (arg3 == NULL) SWIG_fail;
17721 temp3 = true;
17722 }
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 {
17734 if (temp2)
17735 delete arg2;
17736 }
17737 {
17738 if (temp3)
17739 delete arg3;
17740 }
17741 return resultobj;
17742 fail:
17743 {
17744 if (temp2)
17745 delete arg2;
17746 }
17747 {
17748 if (temp3)
17749 delete arg3;
17750 }
17751 return NULL;
17752 }
17753
17754
17755 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17756 PyObject *resultobj;
17757 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17758 wxString *arg2 = 0 ;
17759 long arg3 ;
17760 bool result;
17761 bool temp2 = false ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 PyObject * obj2 = 0 ;
17765 char *kwnames[] = {
17766 (char *) "self",(char *) "key",(char *) "value", NULL
17767 };
17768
17769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17771 if (SWIG_arg_fail(1)) SWIG_fail;
17772 {
17773 arg2 = wxString_in_helper(obj1);
17774 if (arg2 == NULL) SWIG_fail;
17775 temp2 = true;
17776 }
17777 {
17778 arg3 = (long)(SWIG_As_long(obj2));
17779 if (SWIG_arg_fail(3)) SWIG_fail;
17780 }
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17784
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 {
17792 if (temp2)
17793 delete arg2;
17794 }
17795 return resultobj;
17796 fail:
17797 {
17798 if (temp2)
17799 delete arg2;
17800 }
17801 return NULL;
17802 }
17803
17804
17805 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj;
17807 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17808 wxString *arg2 = 0 ;
17809 double arg3 ;
17810 bool result;
17811 bool temp2 = false ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 PyObject * obj2 = 0 ;
17815 char *kwnames[] = {
17816 (char *) "self",(char *) "key",(char *) "value", NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 {
17823 arg2 = wxString_in_helper(obj1);
17824 if (arg2 == NULL) SWIG_fail;
17825 temp2 = true;
17826 }
17827 {
17828 arg3 = (double)(SWIG_As_double(obj2));
17829 if (SWIG_arg_fail(3)) SWIG_fail;
17830 }
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17834
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 {
17839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17840 }
17841 {
17842 if (temp2)
17843 delete arg2;
17844 }
17845 return resultobj;
17846 fail:
17847 {
17848 if (temp2)
17849 delete arg2;
17850 }
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17858 wxString *arg2 = 0 ;
17859 bool arg3 ;
17860 bool result;
17861 bool temp2 = false ;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 PyObject * obj2 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self",(char *) "key",(char *) "value", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 arg2 = wxString_in_helper(obj1);
17874 if (arg2 == NULL) SWIG_fail;
17875 temp2 = true;
17876 }
17877 {
17878 arg3 = (bool)(SWIG_As_bool(obj2));
17879 if (SWIG_arg_fail(3)) SWIG_fail;
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17890 }
17891 {
17892 if (temp2)
17893 delete arg2;
17894 }
17895 return resultobj;
17896 fail:
17897 {
17898 if (temp2)
17899 delete arg2;
17900 }
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17908 bool arg2 = (bool) false ;
17909 bool result;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "self",(char *) "currentOnly", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 if (obj1) {
17920 {
17921 arg2 = (bool)(SWIG_As_bool(obj1));
17922 if (SWIG_arg_fail(2)) SWIG_fail;
17923 }
17924 }
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 result = (bool)(arg1)->Flush(arg2);
17928
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17934 }
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj;
17943 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17944 wxString *arg2 = 0 ;
17945 wxString *arg3 = 0 ;
17946 bool result;
17947 bool temp2 = false ;
17948 bool temp3 = false ;
17949 PyObject * obj0 = 0 ;
17950 PyObject * obj1 = 0 ;
17951 PyObject * obj2 = 0 ;
17952 char *kwnames[] = {
17953 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17954 };
17955
17956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17958 if (SWIG_arg_fail(1)) SWIG_fail;
17959 {
17960 arg2 = wxString_in_helper(obj1);
17961 if (arg2 == NULL) SWIG_fail;
17962 temp2 = true;
17963 }
17964 {
17965 arg3 = wxString_in_helper(obj2);
17966 if (arg3 == NULL) SWIG_fail;
17967 temp3 = true;
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17972
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 {
17977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17978 }
17979 {
17980 if (temp2)
17981 delete arg2;
17982 }
17983 {
17984 if (temp3)
17985 delete arg3;
17986 }
17987 return resultobj;
17988 fail:
17989 {
17990 if (temp2)
17991 delete arg2;
17992 }
17993 {
17994 if (temp3)
17995 delete arg3;
17996 }
17997 return NULL;
17998 }
17999
18000
18001 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18002 PyObject *resultobj;
18003 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18004 wxString *arg2 = 0 ;
18005 wxString *arg3 = 0 ;
18006 bool result;
18007 bool temp2 = false ;
18008 bool temp3 = false ;
18009 PyObject * obj0 = 0 ;
18010 PyObject * obj1 = 0 ;
18011 PyObject * obj2 = 0 ;
18012 char *kwnames[] = {
18013 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18014 };
18015
18016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18018 if (SWIG_arg_fail(1)) SWIG_fail;
18019 {
18020 arg2 = wxString_in_helper(obj1);
18021 if (arg2 == NULL) SWIG_fail;
18022 temp2 = true;
18023 }
18024 {
18025 arg3 = wxString_in_helper(obj2);
18026 if (arg3 == NULL) SWIG_fail;
18027 temp3 = true;
18028 }
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18032
18033 wxPyEndAllowThreads(__tstate);
18034 if (PyErr_Occurred()) SWIG_fail;
18035 }
18036 {
18037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18038 }
18039 {
18040 if (temp2)
18041 delete arg2;
18042 }
18043 {
18044 if (temp3)
18045 delete arg3;
18046 }
18047 return resultobj;
18048 fail:
18049 {
18050 if (temp2)
18051 delete arg2;
18052 }
18053 {
18054 if (temp3)
18055 delete arg3;
18056 }
18057 return NULL;
18058 }
18059
18060
18061 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18062 PyObject *resultobj;
18063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18064 wxString *arg2 = 0 ;
18065 bool arg3 = (bool) true ;
18066 bool result;
18067 bool temp2 = false ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 PyObject * obj2 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 {
18079 arg2 = wxString_in_helper(obj1);
18080 if (arg2 == NULL) SWIG_fail;
18081 temp2 = true;
18082 }
18083 if (obj2) {
18084 {
18085 arg3 = (bool)(SWIG_As_bool(obj2));
18086 if (SWIG_arg_fail(3)) SWIG_fail;
18087 }
18088 }
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18092
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 {
18097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18098 }
18099 {
18100 if (temp2)
18101 delete arg2;
18102 }
18103 return resultobj;
18104 fail:
18105 {
18106 if (temp2)
18107 delete arg2;
18108 }
18109 return NULL;
18110 }
18111
18112
18113 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj;
18115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18116 wxString *arg2 = 0 ;
18117 bool result;
18118 bool temp2 = false ;
18119 PyObject * obj0 = 0 ;
18120 PyObject * obj1 = 0 ;
18121 char *kwnames[] = {
18122 (char *) "self",(char *) "key", NULL
18123 };
18124
18125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18127 if (SWIG_arg_fail(1)) SWIG_fail;
18128 {
18129 arg2 = wxString_in_helper(obj1);
18130 if (arg2 == NULL) SWIG_fail;
18131 temp2 = true;
18132 }
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18136
18137 wxPyEndAllowThreads(__tstate);
18138 if (PyErr_Occurred()) SWIG_fail;
18139 }
18140 {
18141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18142 }
18143 {
18144 if (temp2)
18145 delete arg2;
18146 }
18147 return resultobj;
18148 fail:
18149 {
18150 if (temp2)
18151 delete arg2;
18152 }
18153 return NULL;
18154 }
18155
18156
18157 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18158 PyObject *resultobj;
18159 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18160 bool result;
18161 PyObject * obj0 = 0 ;
18162 char *kwnames[] = {
18163 (char *) "self", NULL
18164 };
18165
18166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18168 if (SWIG_arg_fail(1)) SWIG_fail;
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (bool)(arg1)->DeleteAll();
18172
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 {
18177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18178 }
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18188 bool arg2 = (bool) true ;
18189 PyObject * obj0 = 0 ;
18190 PyObject * obj1 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self",(char *) "doIt", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 if (obj1) {
18199 {
18200 arg2 = (bool)(SWIG_As_bool(obj1));
18201 if (SWIG_arg_fail(2)) SWIG_fail;
18202 }
18203 }
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 (arg1)->SetExpandEnvVars(arg2);
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 Py_INCREF(Py_None); resultobj = Py_None;
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj;
18220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18221 bool result;
18222 PyObject * obj0 = 0 ;
18223 char *kwnames[] = {
18224 (char *) "self", NULL
18225 };
18226
18227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18229 if (SWIG_arg_fail(1)) SWIG_fail;
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 {
18238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18239 }
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18247 PyObject *resultobj;
18248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18249 bool arg2 = (bool) true ;
18250 PyObject * obj0 = 0 ;
18251 PyObject * obj1 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self",(char *) "doIt", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 if (obj1) {
18260 {
18261 arg2 = (bool)(SWIG_As_bool(obj1));
18262 if (SWIG_arg_fail(2)) SWIG_fail;
18263 }
18264 }
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 (arg1)->SetRecordDefaults(arg2);
18268
18269 wxPyEndAllowThreads(__tstate);
18270 if (PyErr_Occurred()) SWIG_fail;
18271 }
18272 Py_INCREF(Py_None); resultobj = Py_None;
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj;
18281 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18282 bool result;
18283 PyObject * obj0 = 0 ;
18284 char *kwnames[] = {
18285 (char *) "self", NULL
18286 };
18287
18288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18290 if (SWIG_arg_fail(1)) SWIG_fail;
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18294
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 {
18299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj;
18309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18310 wxString *arg2 = 0 ;
18311 wxString result;
18312 bool temp2 = false ;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 char *kwnames[] = {
18316 (char *) "self",(char *) "str", NULL
18317 };
18318
18319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18321 if (SWIG_arg_fail(1)) SWIG_fail;
18322 {
18323 arg2 = wxString_in_helper(obj1);
18324 if (arg2 == NULL) SWIG_fail;
18325 temp2 = true;
18326 }
18327 {
18328 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18330
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 {
18335 #if wxUSE_UNICODE
18336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18337 #else
18338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18339 #endif
18340 }
18341 {
18342 if (temp2)
18343 delete arg2;
18344 }
18345 return resultobj;
18346 fail:
18347 {
18348 if (temp2)
18349 delete arg2;
18350 }
18351 return NULL;
18352 }
18353
18354
18355 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj;
18357 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18358 wxString result;
18359 PyObject * obj0 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 result = ((wxConfigBase const *)arg1)->GetAppName();
18370
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 {
18375 #if wxUSE_UNICODE
18376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18377 #else
18378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18379 #endif
18380 }
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj;
18389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18390 wxString result;
18391 PyObject * obj0 = 0 ;
18392 char *kwnames[] = {
18393 (char *) "self", NULL
18394 };
18395
18396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18398 if (SWIG_arg_fail(1)) SWIG_fail;
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = ((wxConfigBase const *)arg1)->GetVendorName();
18402
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 {
18407 #if wxUSE_UNICODE
18408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18409 #else
18410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18411 #endif
18412 }
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj;
18421 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18422 wxString *arg2 = 0 ;
18423 bool temp2 = false ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 char *kwnames[] = {
18427 (char *) "self",(char *) "appName", NULL
18428 };
18429
18430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18432 if (SWIG_arg_fail(1)) SWIG_fail;
18433 {
18434 arg2 = wxString_in_helper(obj1);
18435 if (arg2 == NULL) SWIG_fail;
18436 temp2 = true;
18437 }
18438 {
18439 PyThreadState* __tstate = wxPyBeginAllowThreads();
18440 (arg1)->SetAppName((wxString const &)*arg2);
18441
18442 wxPyEndAllowThreads(__tstate);
18443 if (PyErr_Occurred()) SWIG_fail;
18444 }
18445 Py_INCREF(Py_None); resultobj = Py_None;
18446 {
18447 if (temp2)
18448 delete arg2;
18449 }
18450 return resultobj;
18451 fail:
18452 {
18453 if (temp2)
18454 delete arg2;
18455 }
18456 return NULL;
18457 }
18458
18459
18460 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18461 PyObject *resultobj;
18462 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18463 wxString *arg2 = 0 ;
18464 bool temp2 = false ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "vendorName", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = wxString_in_helper(obj1);
18476 if (arg2 == NULL) SWIG_fail;
18477 temp2 = true;
18478 }
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 (arg1)->SetVendorName((wxString const &)*arg2);
18482
18483 wxPyEndAllowThreads(__tstate);
18484 if (PyErr_Occurred()) SWIG_fail;
18485 }
18486 Py_INCREF(Py_None); resultobj = Py_None;
18487 {
18488 if (temp2)
18489 delete arg2;
18490 }
18491 return resultobj;
18492 fail:
18493 {
18494 if (temp2)
18495 delete arg2;
18496 }
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18504 long arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "style", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = (long)(SWIG_As_long(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 (arg1)->SetStyle(arg2);
18521
18522 wxPyEndAllowThreads(__tstate);
18523 if (PyErr_Occurred()) SWIG_fail;
18524 }
18525 Py_INCREF(Py_None); resultobj = Py_None;
18526 return resultobj;
18527 fail:
18528 return NULL;
18529 }
18530
18531
18532 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18533 PyObject *resultobj;
18534 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18535 long result;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18547
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 {
18552 resultobj = SWIG_From_long((long)(result));
18553 }
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18561 PyObject *obj;
18562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18563 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18564 Py_INCREF(obj);
18565 return Py_BuildValue((char *)"");
18566 }
18567 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18568 PyObject *resultobj;
18569 wxString const &arg1_defvalue = wxPyEmptyString ;
18570 wxString *arg1 = (wxString *) &arg1_defvalue ;
18571 wxString const &arg2_defvalue = wxPyEmptyString ;
18572 wxString *arg2 = (wxString *) &arg2_defvalue ;
18573 wxString const &arg3_defvalue = wxPyEmptyString ;
18574 wxString *arg3 = (wxString *) &arg3_defvalue ;
18575 wxString const &arg4_defvalue = wxPyEmptyString ;
18576 wxString *arg4 = (wxString *) &arg4_defvalue ;
18577 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18578 wxConfig *result;
18579 bool temp1 = false ;
18580 bool temp2 = false ;
18581 bool temp3 = false ;
18582 bool temp4 = false ;
18583 PyObject * obj0 = 0 ;
18584 PyObject * obj1 = 0 ;
18585 PyObject * obj2 = 0 ;
18586 PyObject * obj3 = 0 ;
18587 PyObject * obj4 = 0 ;
18588 char *kwnames[] = {
18589 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18590 };
18591
18592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18593 if (obj0) {
18594 {
18595 arg1 = wxString_in_helper(obj0);
18596 if (arg1 == NULL) SWIG_fail;
18597 temp1 = true;
18598 }
18599 }
18600 if (obj1) {
18601 {
18602 arg2 = wxString_in_helper(obj1);
18603 if (arg2 == NULL) SWIG_fail;
18604 temp2 = true;
18605 }
18606 }
18607 if (obj2) {
18608 {
18609 arg3 = wxString_in_helper(obj2);
18610 if (arg3 == NULL) SWIG_fail;
18611 temp3 = true;
18612 }
18613 }
18614 if (obj3) {
18615 {
18616 arg4 = wxString_in_helper(obj3);
18617 if (arg4 == NULL) SWIG_fail;
18618 temp4 = true;
18619 }
18620 }
18621 if (obj4) {
18622 {
18623 arg5 = (long)(SWIG_As_long(obj4));
18624 if (SWIG_arg_fail(5)) SWIG_fail;
18625 }
18626 }
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18630
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18635 {
18636 if (temp1)
18637 delete arg1;
18638 }
18639 {
18640 if (temp2)
18641 delete arg2;
18642 }
18643 {
18644 if (temp3)
18645 delete arg3;
18646 }
18647 {
18648 if (temp4)
18649 delete arg4;
18650 }
18651 return resultobj;
18652 fail:
18653 {
18654 if (temp1)
18655 delete arg1;
18656 }
18657 {
18658 if (temp2)
18659 delete arg2;
18660 }
18661 {
18662 if (temp3)
18663 delete arg3;
18664 }
18665 {
18666 if (temp4)
18667 delete arg4;
18668 }
18669 return NULL;
18670 }
18671
18672
18673 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj;
18675 wxConfig *arg1 = (wxConfig *) 0 ;
18676 PyObject * obj0 = 0 ;
18677 char *kwnames[] = {
18678 (char *) "self", NULL
18679 };
18680
18681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18683 if (SWIG_arg_fail(1)) SWIG_fail;
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 delete arg1;
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 Py_INCREF(Py_None); resultobj = Py_None;
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18699 PyObject *obj;
18700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18701 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18702 Py_INCREF(obj);
18703 return Py_BuildValue((char *)"");
18704 }
18705 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18706 PyObject *resultobj;
18707 wxString const &arg1_defvalue = wxPyEmptyString ;
18708 wxString *arg1 = (wxString *) &arg1_defvalue ;
18709 wxString const &arg2_defvalue = wxPyEmptyString ;
18710 wxString *arg2 = (wxString *) &arg2_defvalue ;
18711 wxString const &arg3_defvalue = wxPyEmptyString ;
18712 wxString *arg3 = (wxString *) &arg3_defvalue ;
18713 wxString const &arg4_defvalue = wxPyEmptyString ;
18714 wxString *arg4 = (wxString *) &arg4_defvalue ;
18715 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18716 wxFileConfig *result;
18717 bool temp1 = false ;
18718 bool temp2 = false ;
18719 bool temp3 = false ;
18720 bool temp4 = false ;
18721 PyObject * obj0 = 0 ;
18722 PyObject * obj1 = 0 ;
18723 PyObject * obj2 = 0 ;
18724 PyObject * obj3 = 0 ;
18725 PyObject * obj4 = 0 ;
18726 char *kwnames[] = {
18727 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18728 };
18729
18730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18731 if (obj0) {
18732 {
18733 arg1 = wxString_in_helper(obj0);
18734 if (arg1 == NULL) SWIG_fail;
18735 temp1 = true;
18736 }
18737 }
18738 if (obj1) {
18739 {
18740 arg2 = wxString_in_helper(obj1);
18741 if (arg2 == NULL) SWIG_fail;
18742 temp2 = true;
18743 }
18744 }
18745 if (obj2) {
18746 {
18747 arg3 = wxString_in_helper(obj2);
18748 if (arg3 == NULL) SWIG_fail;
18749 temp3 = true;
18750 }
18751 }
18752 if (obj3) {
18753 {
18754 arg4 = wxString_in_helper(obj3);
18755 if (arg4 == NULL) SWIG_fail;
18756 temp4 = true;
18757 }
18758 }
18759 if (obj4) {
18760 {
18761 arg5 = (long)(SWIG_As_long(obj4));
18762 if (SWIG_arg_fail(5)) SWIG_fail;
18763 }
18764 }
18765 {
18766 PyThreadState* __tstate = wxPyBeginAllowThreads();
18767 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18768
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18773 {
18774 if (temp1)
18775 delete arg1;
18776 }
18777 {
18778 if (temp2)
18779 delete arg2;
18780 }
18781 {
18782 if (temp3)
18783 delete arg3;
18784 }
18785 {
18786 if (temp4)
18787 delete arg4;
18788 }
18789 return resultobj;
18790 fail:
18791 {
18792 if (temp1)
18793 delete arg1;
18794 }
18795 {
18796 if (temp2)
18797 delete arg2;
18798 }
18799 {
18800 if (temp3)
18801 delete arg3;
18802 }
18803 {
18804 if (temp4)
18805 delete arg4;
18806 }
18807 return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18814 PyObject * obj0 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "self", NULL
18817 };
18818
18819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18821 if (SWIG_arg_fail(1)) SWIG_fail;
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 delete arg1;
18825
18826 wxPyEndAllowThreads(__tstate);
18827 if (PyErr_Occurred()) SWIG_fail;
18828 }
18829 Py_INCREF(Py_None); resultobj = Py_None;
18830 return resultobj;
18831 fail:
18832 return NULL;
18833 }
18834
18835
18836 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18837 PyObject *obj;
18838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18839 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18840 Py_INCREF(obj);
18841 return Py_BuildValue((char *)"");
18842 }
18843 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj;
18845 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18846 wxString *arg2 = 0 ;
18847 wxConfigPathChanger *result;
18848 bool temp2 = false ;
18849 PyObject * obj0 = 0 ;
18850 PyObject * obj1 = 0 ;
18851 char *kwnames[] = {
18852 (char *) "config",(char *) "entry", NULL
18853 };
18854
18855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18857 if (SWIG_arg_fail(1)) SWIG_fail;
18858 {
18859 arg2 = wxString_in_helper(obj1);
18860 if (arg2 == NULL) SWIG_fail;
18861 temp2 = true;
18862 }
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18871 {
18872 if (temp2)
18873 delete arg2;
18874 }
18875 return resultobj;
18876 fail:
18877 {
18878 if (temp2)
18879 delete arg2;
18880 }
18881 return NULL;
18882 }
18883
18884
18885 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18886 PyObject *resultobj;
18887 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18888 PyObject * obj0 = 0 ;
18889 char *kwnames[] = {
18890 (char *) "self", NULL
18891 };
18892
18893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18895 if (SWIG_arg_fail(1)) SWIG_fail;
18896 {
18897 PyThreadState* __tstate = wxPyBeginAllowThreads();
18898 delete arg1;
18899
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 Py_INCREF(Py_None); resultobj = Py_None;
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj;
18912 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18913 wxString *result;
18914 PyObject * obj0 = 0 ;
18915 char *kwnames[] = {
18916 (char *) "self", NULL
18917 };
18918
18919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18921 if (SWIG_arg_fail(1)) SWIG_fail;
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 {
18925 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18926 result = (wxString *) &_result_ref;
18927 }
18928
18929 wxPyEndAllowThreads(__tstate);
18930 if (PyErr_Occurred()) SWIG_fail;
18931 }
18932 {
18933 #if wxUSE_UNICODE
18934 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18935 #else
18936 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18937 #endif
18938 }
18939 return resultobj;
18940 fail:
18941 return NULL;
18942 }
18943
18944
18945 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18946 PyObject *obj;
18947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18948 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18949 Py_INCREF(obj);
18950 return Py_BuildValue((char *)"");
18951 }
18952 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxString *arg1 = 0 ;
18955 wxString result;
18956 bool temp1 = false ;
18957 PyObject * obj0 = 0 ;
18958 char *kwnames[] = {
18959 (char *) "sz", NULL
18960 };
18961
18962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18963 {
18964 arg1 = wxString_in_helper(obj0);
18965 if (arg1 == NULL) SWIG_fail;
18966 temp1 = true;
18967 }
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 result = wxExpandEnvVars((wxString const &)*arg1);
18971
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 {
18976 #if wxUSE_UNICODE
18977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18978 #else
18979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18980 #endif
18981 }
18982 {
18983 if (temp1)
18984 delete arg1;
18985 }
18986 return resultobj;
18987 fail:
18988 {
18989 if (temp1)
18990 delete arg1;
18991 }
18992 return NULL;
18993 }
18994
18995
18996 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18997 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18998 return 1;
18999 }
19000
19001
19002 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19003 PyObject *pyobj;
19004
19005 {
19006 #if wxUSE_UNICODE
19007 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19008 #else
19009 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19010 #endif
19011 }
19012 return pyobj;
19013 }
19014
19015
19016 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19017 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19018 return 1;
19019 }
19020
19021
19022 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19023 PyObject *pyobj;
19024
19025 {
19026 #if wxUSE_UNICODE
19027 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19028 #else
19029 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19030 #endif
19031 }
19032 return pyobj;
19033 }
19034
19035
19036 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj;
19038 wxDateTime::Country arg1 ;
19039 PyObject * obj0 = 0 ;
19040 char *kwnames[] = {
19041 (char *) "country", NULL
19042 };
19043
19044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19045 {
19046 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19047 if (SWIG_arg_fail(1)) SWIG_fail;
19048 }
19049 {
19050 PyThreadState* __tstate = wxPyBeginAllowThreads();
19051 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19052
19053 wxPyEndAllowThreads(__tstate);
19054 if (PyErr_Occurred()) SWIG_fail;
19055 }
19056 Py_INCREF(Py_None); resultobj = Py_None;
19057 return resultobj;
19058 fail:
19059 return NULL;
19060 }
19061
19062
19063 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19064 PyObject *resultobj;
19065 wxDateTime::Country result;
19066 char *kwnames[] = {
19067 NULL
19068 };
19069
19070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = (wxDateTime::Country)wxDateTime::GetCountry();
19074
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 resultobj = SWIG_From_int((result));
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19088 bool result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "country", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19095 if (obj0) {
19096 {
19097 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 }
19100 }
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 {
19109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19110 }
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19120 int result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "cal", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19127 if (obj0) {
19128 {
19129 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19130 if (SWIG_arg_fail(1)) SWIG_fail;
19131 }
19132 }
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19136
19137 wxPyEndAllowThreads(__tstate);
19138 if (PyErr_Occurred()) SWIG_fail;
19139 }
19140 {
19141 resultobj = SWIG_From_int((int)(result));
19142 }
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj;
19151 int arg1 ;
19152 int result;
19153 PyObject * obj0 = 0 ;
19154 char *kwnames[] = {
19155 (char *) "year", NULL
19156 };
19157
19158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19159 {
19160 arg1 = (int)(SWIG_As_int(obj0));
19161 if (SWIG_arg_fail(1)) SWIG_fail;
19162 }
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 result = (int)wxDateTime::ConvertYearToBC(arg1);
19166
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 {
19171 resultobj = SWIG_From_int((int)(result));
19172 }
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19182 wxDateTime::Month result;
19183 PyObject * obj0 = 0 ;
19184 char *kwnames[] = {
19185 (char *) "cal", NULL
19186 };
19187
19188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19189 if (obj0) {
19190 {
19191 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19192 if (SWIG_arg_fail(1)) SWIG_fail;
19193 }
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_From_int((result));
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 int arg1 = (int) wxDateTime::Inv_Year ;
19212 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19213 bool result;
19214 PyObject * obj0 = 0 ;
19215 PyObject * obj1 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "year",(char *) "cal", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19221 if (obj0) {
19222 {
19223 arg1 = (int)(SWIG_As_int(obj0));
19224 if (SWIG_arg_fail(1)) SWIG_fail;
19225 }
19226 }
19227 if (obj1) {
19228 {
19229 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19230 if (SWIG_arg_fail(2)) SWIG_fail;
19231 }
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 int arg1 = (int) wxDateTime::Inv_Year ;
19252 int result;
19253 PyObject * obj0 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "year", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19259 if (obj0) {
19260 {
19261 arg1 = (int)(SWIG_As_int(obj0));
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 }
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (int)wxDateTime::GetCentury(arg1);
19268
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 {
19273 resultobj = SWIG_From_int((int)(result));
19274 }
19275 return resultobj;
19276 fail:
19277 return NULL;
19278 }
19279
19280
19281 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19282 PyObject *resultobj;
19283 int arg1 ;
19284 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19285 int result;
19286 PyObject * obj0 = 0 ;
19287 PyObject * obj1 = 0 ;
19288 char *kwnames[] = {
19289 (char *) "year",(char *) "cal", NULL
19290 };
19291
19292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19293 {
19294 arg1 = (int)(SWIG_As_int(obj0));
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 }
19297 if (obj1) {
19298 {
19299 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19300 if (SWIG_arg_fail(2)) SWIG_fail;
19301 }
19302 }
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19306
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 {
19311 resultobj = SWIG_From_int((int)(result));
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxDateTime::Month arg1 ;
19322 int arg2 = (int) wxDateTime::Inv_Year ;
19323 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19324 int result;
19325 PyObject * obj0 = 0 ;
19326 PyObject * obj1 = 0 ;
19327 PyObject * obj2 = 0 ;
19328 char *kwnames[] = {
19329 (char *) "month",(char *) "year",(char *) "cal", NULL
19330 };
19331
19332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19333 {
19334 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19335 if (SWIG_arg_fail(1)) SWIG_fail;
19336 }
19337 if (obj1) {
19338 {
19339 arg2 = (int)(SWIG_As_int(obj1));
19340 if (SWIG_arg_fail(2)) SWIG_fail;
19341 }
19342 }
19343 if (obj2) {
19344 {
19345 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19346 if (SWIG_arg_fail(3)) SWIG_fail;
19347 }
19348 }
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19352
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 {
19357 resultobj = SWIG_From_int((int)(result));
19358 }
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj;
19367 wxDateTime::Month arg1 ;
19368 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19369 wxString result;
19370 PyObject * obj0 = 0 ;
19371 PyObject * obj1 = 0 ;
19372 char *kwnames[] = {
19373 (char *) "month",(char *) "flags", NULL
19374 };
19375
19376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19377 {
19378 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19379 if (SWIG_arg_fail(1)) SWIG_fail;
19380 }
19381 if (obj1) {
19382 {
19383 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 }
19386 }
19387 {
19388 PyThreadState* __tstate = wxPyBeginAllowThreads();
19389 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19390
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 {
19395 #if wxUSE_UNICODE
19396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19397 #else
19398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19399 #endif
19400 }
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19408 PyObject *resultobj;
19409 wxDateTime::WeekDay arg1 ;
19410 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19411 wxString result;
19412 PyObject * obj0 = 0 ;
19413 PyObject * obj1 = 0 ;
19414 char *kwnames[] = {
19415 (char *) "weekday",(char *) "flags", NULL
19416 };
19417
19418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19419 {
19420 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19421 if (SWIG_arg_fail(1)) SWIG_fail;
19422 }
19423 if (obj1) {
19424 {
19425 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19426 if (SWIG_arg_fail(2)) SWIG_fail;
19427 }
19428 }
19429 {
19430 PyThreadState* __tstate = wxPyBeginAllowThreads();
19431 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19432
19433 wxPyEndAllowThreads(__tstate);
19434 if (PyErr_Occurred()) SWIG_fail;
19435 }
19436 {
19437 #if wxUSE_UNICODE
19438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19439 #else
19440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19441 #endif
19442 }
19443 return resultobj;
19444 fail:
19445 return NULL;
19446 }
19447
19448
19449 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj;
19451 PyObject *result;
19452 char *kwnames[] = {
19453 NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19457 {
19458 PyThreadState* __tstate = wxPyBeginAllowThreads();
19459 result = (PyObject *)DateTime_GetAmPmStrings();
19460
19461 wxPyEndAllowThreads(__tstate);
19462 if (PyErr_Occurred()) SWIG_fail;
19463 }
19464 resultobj = result;
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj;
19473 int arg1 = (int) wxDateTime::Inv_Year ;
19474 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19475 bool result;
19476 PyObject * obj0 = 0 ;
19477 PyObject * obj1 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "year",(char *) "country", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19483 if (obj0) {
19484 {
19485 arg1 = (int)(SWIG_As_int(obj0));
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 }
19488 }
19489 if (obj1) {
19490 {
19491 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19492 if (SWIG_arg_fail(2)) SWIG_fail;
19493 }
19494 }
19495 {
19496 PyThreadState* __tstate = wxPyBeginAllowThreads();
19497 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19498
19499 wxPyEndAllowThreads(__tstate);
19500 if (PyErr_Occurred()) SWIG_fail;
19501 }
19502 {
19503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19504 }
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj;
19513 int arg1 = (int) wxDateTime::Inv_Year ;
19514 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19515 wxDateTime result;
19516 PyObject * obj0 = 0 ;
19517 PyObject * obj1 = 0 ;
19518 char *kwnames[] = {
19519 (char *) "year",(char *) "country", NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19523 if (obj0) {
19524 {
19525 arg1 = (int)(SWIG_As_int(obj0));
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 }
19528 }
19529 if (obj1) {
19530 {
19531 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19532 if (SWIG_arg_fail(2)) SWIG_fail;
19533 }
19534 }
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19538
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 {
19543 wxDateTime * resultptr;
19544 resultptr = new wxDateTime((wxDateTime &)(result));
19545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19546 }
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj;
19555 int arg1 = (int) wxDateTime::Inv_Year ;
19556 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19557 wxDateTime result;
19558 PyObject * obj0 = 0 ;
19559 PyObject * obj1 = 0 ;
19560 char *kwnames[] = {
19561 (char *) "year",(char *) "country", NULL
19562 };
19563
19564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19565 if (obj0) {
19566 {
19567 arg1 = (int)(SWIG_As_int(obj0));
19568 if (SWIG_arg_fail(1)) SWIG_fail;
19569 }
19570 }
19571 if (obj1) {
19572 {
19573 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19574 if (SWIG_arg_fail(2)) SWIG_fail;
19575 }
19576 }
19577 {
19578 PyThreadState* __tstate = wxPyBeginAllowThreads();
19579 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19580
19581 wxPyEndAllowThreads(__tstate);
19582 if (PyErr_Occurred()) SWIG_fail;
19583 }
19584 {
19585 wxDateTime * resultptr;
19586 resultptr = new wxDateTime((wxDateTime &)(result));
19587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19588 }
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19596 PyObject *resultobj;
19597 wxDateTime result;
19598 char *kwnames[] = {
19599 NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = wxDateTime::Now();
19606
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 {
19611 wxDateTime * resultptr;
19612 resultptr = new wxDateTime((wxDateTime &)(result));
19613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19614 }
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19622 PyObject *resultobj;
19623 wxDateTime result;
19624 char *kwnames[] = {
19625 NULL
19626 };
19627
19628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19629 {
19630 PyThreadState* __tstate = wxPyBeginAllowThreads();
19631 result = wxDateTime::UNow();
19632
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 {
19637 wxDateTime * resultptr;
19638 resultptr = new wxDateTime((wxDateTime &)(result));
19639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19640 }
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19648 PyObject *resultobj;
19649 wxDateTime result;
19650 char *kwnames[] = {
19651 NULL
19652 };
19653
19654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19655 {
19656 PyThreadState* __tstate = wxPyBeginAllowThreads();
19657 result = wxDateTime::Today();
19658
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 {
19663 wxDateTime * resultptr;
19664 resultptr = new wxDateTime((wxDateTime &)(result));
19665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19666 }
19667 return resultobj;
19668 fail:
19669 return NULL;
19670 }
19671
19672
19673 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19674 PyObject *resultobj;
19675 wxDateTime *result;
19676 char *kwnames[] = {
19677 NULL
19678 };
19679
19680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 result = (wxDateTime *)new wxDateTime();
19684
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19696 PyObject *resultobj;
19697 time_t arg1 ;
19698 wxDateTime *result;
19699 PyObject * obj0 = 0 ;
19700 char *kwnames[] = {
19701 (char *) "timet", NULL
19702 };
19703
19704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19705 {
19706 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19707 if (SWIG_arg_fail(1)) SWIG_fail;
19708 }
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 result = (wxDateTime *)new wxDateTime(arg1);
19712
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj;
19725 double arg1 ;
19726 wxDateTime *result;
19727 PyObject * obj0 = 0 ;
19728 char *kwnames[] = {
19729 (char *) "jdn", NULL
19730 };
19731
19732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19733 {
19734 arg1 = (double)(SWIG_As_double(obj0));
19735 if (SWIG_arg_fail(1)) SWIG_fail;
19736 }
19737 {
19738 PyThreadState* __tstate = wxPyBeginAllowThreads();
19739 result = (wxDateTime *)new wxDateTime(arg1);
19740
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj;
19753 int arg1 ;
19754 int arg2 = (int) 0 ;
19755 int arg3 = (int) 0 ;
19756 int arg4 = (int) 0 ;
19757 wxDateTime *result;
19758 PyObject * obj0 = 0 ;
19759 PyObject * obj1 = 0 ;
19760 PyObject * obj2 = 0 ;
19761 PyObject * obj3 = 0 ;
19762 char *kwnames[] = {
19763 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19764 };
19765
19766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19767 {
19768 arg1 = (int)(SWIG_As_int(obj0));
19769 if (SWIG_arg_fail(1)) SWIG_fail;
19770 }
19771 if (obj1) {
19772 {
19773 arg2 = (int)(SWIG_As_int(obj1));
19774 if (SWIG_arg_fail(2)) SWIG_fail;
19775 }
19776 }
19777 if (obj2) {
19778 {
19779 arg3 = (int)(SWIG_As_int(obj2));
19780 if (SWIG_arg_fail(3)) SWIG_fail;
19781 }
19782 }
19783 if (obj3) {
19784 {
19785 arg4 = (int)(SWIG_As_int(obj3));
19786 if (SWIG_arg_fail(4)) SWIG_fail;
19787 }
19788 }
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19792
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19804 PyObject *resultobj;
19805 int arg1 ;
19806 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19807 int arg3 = (int) wxDateTime::Inv_Year ;
19808 int arg4 = (int) 0 ;
19809 int arg5 = (int) 0 ;
19810 int arg6 = (int) 0 ;
19811 int arg7 = (int) 0 ;
19812 wxDateTime *result;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 PyObject * obj2 = 0 ;
19816 PyObject * obj3 = 0 ;
19817 PyObject * obj4 = 0 ;
19818 PyObject * obj5 = 0 ;
19819 PyObject * obj6 = 0 ;
19820 char *kwnames[] = {
19821 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19822 };
19823
19824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19825 {
19826 arg1 = (int)(SWIG_As_int(obj0));
19827 if (SWIG_arg_fail(1)) SWIG_fail;
19828 }
19829 if (obj1) {
19830 {
19831 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19832 if (SWIG_arg_fail(2)) SWIG_fail;
19833 }
19834 }
19835 if (obj2) {
19836 {
19837 arg3 = (int)(SWIG_As_int(obj2));
19838 if (SWIG_arg_fail(3)) SWIG_fail;
19839 }
19840 }
19841 if (obj3) {
19842 {
19843 arg4 = (int)(SWIG_As_int(obj3));
19844 if (SWIG_arg_fail(4)) SWIG_fail;
19845 }
19846 }
19847 if (obj4) {
19848 {
19849 arg5 = (int)(SWIG_As_int(obj4));
19850 if (SWIG_arg_fail(5)) SWIG_fail;
19851 }
19852 }
19853 if (obj5) {
19854 {
19855 arg6 = (int)(SWIG_As_int(obj5));
19856 if (SWIG_arg_fail(6)) SWIG_fail;
19857 }
19858 }
19859 if (obj6) {
19860 {
19861 arg7 = (int)(SWIG_As_int(obj6));
19862 if (SWIG_arg_fail(7)) SWIG_fail;
19863 }
19864 }
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj;
19881 wxDateTime *arg1 = (wxDateTime *) 0 ;
19882 PyObject * obj0 = 0 ;
19883 char *kwnames[] = {
19884 (char *) "self", NULL
19885 };
19886
19887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19889 if (SWIG_arg_fail(1)) SWIG_fail;
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 delete arg1;
19893
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 Py_INCREF(Py_None); resultobj = Py_None;
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19905 PyObject *resultobj;
19906 wxDateTime *arg1 = (wxDateTime *) 0 ;
19907 wxDateTime *result;
19908 PyObject * obj0 = 0 ;
19909 char *kwnames[] = {
19910 (char *) "self", NULL
19911 };
19912
19913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19915 if (SWIG_arg_fail(1)) SWIG_fail;
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 {
19919 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19920 result = (wxDateTime *) &_result_ref;
19921 }
19922
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxDateTime *arg1 = (wxDateTime *) 0 ;
19936 time_t arg2 ;
19937 wxDateTime *result;
19938 PyObject * obj0 = 0 ;
19939 PyObject * obj1 = 0 ;
19940 char *kwnames[] = {
19941 (char *) "self",(char *) "timet", NULL
19942 };
19943
19944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19946 if (SWIG_arg_fail(1)) SWIG_fail;
19947 {
19948 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19949 if (SWIG_arg_fail(2)) SWIG_fail;
19950 }
19951 {
19952 PyThreadState* __tstate = wxPyBeginAllowThreads();
19953 {
19954 wxDateTime &_result_ref = (arg1)->Set(arg2);
19955 result = (wxDateTime *) &_result_ref;
19956 }
19957
19958 wxPyEndAllowThreads(__tstate);
19959 if (PyErr_Occurred()) SWIG_fail;
19960 }
19961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj;
19970 wxDateTime *arg1 = (wxDateTime *) 0 ;
19971 double arg2 ;
19972 wxDateTime *result;
19973 PyObject * obj0 = 0 ;
19974 PyObject * obj1 = 0 ;
19975 char *kwnames[] = {
19976 (char *) "self",(char *) "jdn", NULL
19977 };
19978
19979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19981 if (SWIG_arg_fail(1)) SWIG_fail;
19982 {
19983 arg2 = (double)(SWIG_As_double(obj1));
19984 if (SWIG_arg_fail(2)) SWIG_fail;
19985 }
19986 {
19987 PyThreadState* __tstate = wxPyBeginAllowThreads();
19988 {
19989 wxDateTime &_result_ref = (arg1)->Set(arg2);
19990 result = (wxDateTime *) &_result_ref;
19991 }
19992
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19997 return resultobj;
19998 fail:
19999 return NULL;
20000 }
20001
20002
20003 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20004 PyObject *resultobj;
20005 wxDateTime *arg1 = (wxDateTime *) 0 ;
20006 int arg2 ;
20007 int arg3 = (int) 0 ;
20008 int arg4 = (int) 0 ;
20009 int arg5 = (int) 0 ;
20010 wxDateTime *result;
20011 PyObject * obj0 = 0 ;
20012 PyObject * obj1 = 0 ;
20013 PyObject * obj2 = 0 ;
20014 PyObject * obj3 = 0 ;
20015 PyObject * obj4 = 0 ;
20016 char *kwnames[] = {
20017 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20018 };
20019
20020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20022 if (SWIG_arg_fail(1)) SWIG_fail;
20023 {
20024 arg2 = (int)(SWIG_As_int(obj1));
20025 if (SWIG_arg_fail(2)) SWIG_fail;
20026 }
20027 if (obj2) {
20028 {
20029 arg3 = (int)(SWIG_As_int(obj2));
20030 if (SWIG_arg_fail(3)) SWIG_fail;
20031 }
20032 }
20033 if (obj3) {
20034 {
20035 arg4 = (int)(SWIG_As_int(obj3));
20036 if (SWIG_arg_fail(4)) SWIG_fail;
20037 }
20038 }
20039 if (obj4) {
20040 {
20041 arg5 = (int)(SWIG_As_int(obj4));
20042 if (SWIG_arg_fail(5)) SWIG_fail;
20043 }
20044 }
20045 {
20046 PyThreadState* __tstate = wxPyBeginAllowThreads();
20047 {
20048 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20049 result = (wxDateTime *) &_result_ref;
20050 }
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxDateTime *arg1 = (wxDateTime *) 0 ;
20065 int arg2 ;
20066 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20067 int arg4 = (int) wxDateTime::Inv_Year ;
20068 int arg5 = (int) 0 ;
20069 int arg6 = (int) 0 ;
20070 int arg7 = (int) 0 ;
20071 int arg8 = (int) 0 ;
20072 wxDateTime *result;
20073 PyObject * obj0 = 0 ;
20074 PyObject * obj1 = 0 ;
20075 PyObject * obj2 = 0 ;
20076 PyObject * obj3 = 0 ;
20077 PyObject * obj4 = 0 ;
20078 PyObject * obj5 = 0 ;
20079 PyObject * obj6 = 0 ;
20080 PyObject * obj7 = 0 ;
20081 char *kwnames[] = {
20082 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20083 };
20084
20085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20087 if (SWIG_arg_fail(1)) SWIG_fail;
20088 {
20089 arg2 = (int)(SWIG_As_int(obj1));
20090 if (SWIG_arg_fail(2)) SWIG_fail;
20091 }
20092 if (obj2) {
20093 {
20094 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20095 if (SWIG_arg_fail(3)) SWIG_fail;
20096 }
20097 }
20098 if (obj3) {
20099 {
20100 arg4 = (int)(SWIG_As_int(obj3));
20101 if (SWIG_arg_fail(4)) SWIG_fail;
20102 }
20103 }
20104 if (obj4) {
20105 {
20106 arg5 = (int)(SWIG_As_int(obj4));
20107 if (SWIG_arg_fail(5)) SWIG_fail;
20108 }
20109 }
20110 if (obj5) {
20111 {
20112 arg6 = (int)(SWIG_As_int(obj5));
20113 if (SWIG_arg_fail(6)) SWIG_fail;
20114 }
20115 }
20116 if (obj6) {
20117 {
20118 arg7 = (int)(SWIG_As_int(obj6));
20119 if (SWIG_arg_fail(7)) SWIG_fail;
20120 }
20121 }
20122 if (obj7) {
20123 {
20124 arg8 = (int)(SWIG_As_int(obj7));
20125 if (SWIG_arg_fail(8)) SWIG_fail;
20126 }
20127 }
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 {
20131 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20132 result = (wxDateTime *) &_result_ref;
20133 }
20134
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20146 PyObject *resultobj;
20147 wxDateTime *arg1 = (wxDateTime *) 0 ;
20148 wxDateTime *result;
20149 PyObject * obj0 = 0 ;
20150 char *kwnames[] = {
20151 (char *) "self", NULL
20152 };
20153
20154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20156 if (SWIG_arg_fail(1)) SWIG_fail;
20157 {
20158 PyThreadState* __tstate = wxPyBeginAllowThreads();
20159 {
20160 wxDateTime &_result_ref = (arg1)->ResetTime();
20161 result = (wxDateTime *) &_result_ref;
20162 }
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj;
20176 wxDateTime *arg1 = (wxDateTime *) 0 ;
20177 int arg2 ;
20178 wxDateTime *result;
20179 PyObject * obj0 = 0 ;
20180 PyObject * obj1 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self",(char *) "year", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 arg2 = (int)(SWIG_As_int(obj1));
20190 if (SWIG_arg_fail(2)) SWIG_fail;
20191 }
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 {
20195 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20196 result = (wxDateTime *) &_result_ref;
20197 }
20198
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20210 PyObject *resultobj;
20211 wxDateTime *arg1 = (wxDateTime *) 0 ;
20212 wxDateTime::Month arg2 ;
20213 wxDateTime *result;
20214 PyObject * obj0 = 0 ;
20215 PyObject * obj1 = 0 ;
20216 char *kwnames[] = {
20217 (char *) "self",(char *) "month", NULL
20218 };
20219
20220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20222 if (SWIG_arg_fail(1)) SWIG_fail;
20223 {
20224 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20225 if (SWIG_arg_fail(2)) SWIG_fail;
20226 }
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 {
20230 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20231 result = (wxDateTime *) &_result_ref;
20232 }
20233
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj;
20246 wxDateTime *arg1 = (wxDateTime *) 0 ;
20247 int arg2 ;
20248 wxDateTime *result;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 char *kwnames[] = {
20252 (char *) "self",(char *) "day", NULL
20253 };
20254
20255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20257 if (SWIG_arg_fail(1)) SWIG_fail;
20258 {
20259 arg2 = (int)(SWIG_As_int(obj1));
20260 if (SWIG_arg_fail(2)) SWIG_fail;
20261 }
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 {
20265 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20266 result = (wxDateTime *) &_result_ref;
20267 }
20268
20269 wxPyEndAllowThreads(__tstate);
20270 if (PyErr_Occurred()) SWIG_fail;
20271 }
20272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxDateTime *arg1 = (wxDateTime *) 0 ;
20282 int arg2 ;
20283 wxDateTime *result;
20284 PyObject * obj0 = 0 ;
20285 PyObject * obj1 = 0 ;
20286 char *kwnames[] = {
20287 (char *) "self",(char *) "hour", NULL
20288 };
20289
20290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20292 if (SWIG_arg_fail(1)) SWIG_fail;
20293 {
20294 arg2 = (int)(SWIG_As_int(obj1));
20295 if (SWIG_arg_fail(2)) SWIG_fail;
20296 }
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 {
20300 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20301 result = (wxDateTime *) &_result_ref;
20302 }
20303
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20315 PyObject *resultobj;
20316 wxDateTime *arg1 = (wxDateTime *) 0 ;
20317 int arg2 ;
20318 wxDateTime *result;
20319 PyObject * obj0 = 0 ;
20320 PyObject * obj1 = 0 ;
20321 char *kwnames[] = {
20322 (char *) "self",(char *) "minute", NULL
20323 };
20324
20325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20327 if (SWIG_arg_fail(1)) SWIG_fail;
20328 {
20329 arg2 = (int)(SWIG_As_int(obj1));
20330 if (SWIG_arg_fail(2)) SWIG_fail;
20331 }
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 {
20335 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20336 result = (wxDateTime *) &_result_ref;
20337 }
20338
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20343 return resultobj;
20344 fail:
20345 return NULL;
20346 }
20347
20348
20349 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20350 PyObject *resultobj;
20351 wxDateTime *arg1 = (wxDateTime *) 0 ;
20352 int arg2 ;
20353 wxDateTime *result;
20354 PyObject * obj0 = 0 ;
20355 PyObject * obj1 = 0 ;
20356 char *kwnames[] = {
20357 (char *) "self",(char *) "second", NULL
20358 };
20359
20360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20362 if (SWIG_arg_fail(1)) SWIG_fail;
20363 {
20364 arg2 = (int)(SWIG_As_int(obj1));
20365 if (SWIG_arg_fail(2)) SWIG_fail;
20366 }
20367 {
20368 PyThreadState* __tstate = wxPyBeginAllowThreads();
20369 {
20370 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20371 result = (wxDateTime *) &_result_ref;
20372 }
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxDateTime *arg1 = (wxDateTime *) 0 ;
20387 int arg2 ;
20388 wxDateTime *result;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self",(char *) "millisecond", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 arg2 = (int)(SWIG_As_int(obj1));
20400 if (SWIG_arg_fail(2)) SWIG_fail;
20401 }
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 {
20405 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20406 result = (wxDateTime *) &_result_ref;
20407 }
20408
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20420 PyObject *resultobj;
20421 wxDateTime *arg1 = (wxDateTime *) 0 ;
20422 wxDateTime::WeekDay arg2 ;
20423 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20424 wxDateTime *result;
20425 PyObject * obj0 = 0 ;
20426 PyObject * obj1 = 0 ;
20427 PyObject * obj2 = 0 ;
20428 char *kwnames[] = {
20429 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20430 };
20431
20432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20434 if (SWIG_arg_fail(1)) SWIG_fail;
20435 {
20436 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20437 if (SWIG_arg_fail(2)) SWIG_fail;
20438 }
20439 if (obj2) {
20440 {
20441 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20442 if (SWIG_arg_fail(3)) SWIG_fail;
20443 }
20444 }
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 {
20448 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20449 result = (wxDateTime *) &_result_ref;
20450 }
20451
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj;
20464 wxDateTime *arg1 = (wxDateTime *) 0 ;
20465 wxDateTime::WeekDay arg2 ;
20466 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20467 wxDateTime result;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 PyObject * obj2 = 0 ;
20471 char *kwnames[] = {
20472 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20473 };
20474
20475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20477 if (SWIG_arg_fail(1)) SWIG_fail;
20478 {
20479 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20480 if (SWIG_arg_fail(2)) SWIG_fail;
20481 }
20482 if (obj2) {
20483 {
20484 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20485 if (SWIG_arg_fail(3)) SWIG_fail;
20486 }
20487 }
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20491
20492 wxPyEndAllowThreads(__tstate);
20493 if (PyErr_Occurred()) SWIG_fail;
20494 }
20495 {
20496 wxDateTime * resultptr;
20497 resultptr = new wxDateTime((wxDateTime &)(result));
20498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20499 }
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20507 PyObject *resultobj;
20508 wxDateTime *arg1 = (wxDateTime *) 0 ;
20509 wxDateTime::WeekDay arg2 ;
20510 wxDateTime *result;
20511 PyObject * obj0 = 0 ;
20512 PyObject * obj1 = 0 ;
20513 char *kwnames[] = {
20514 (char *) "self",(char *) "weekday", NULL
20515 };
20516
20517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20519 if (SWIG_arg_fail(1)) SWIG_fail;
20520 {
20521 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20522 if (SWIG_arg_fail(2)) SWIG_fail;
20523 }
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 {
20527 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20528 result = (wxDateTime *) &_result_ref;
20529 }
20530
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20535 return resultobj;
20536 fail:
20537 return NULL;
20538 }
20539
20540
20541 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20542 PyObject *resultobj;
20543 wxDateTime *arg1 = (wxDateTime *) 0 ;
20544 wxDateTime::WeekDay arg2 ;
20545 wxDateTime result;
20546 PyObject * obj0 = 0 ;
20547 PyObject * obj1 = 0 ;
20548 char *kwnames[] = {
20549 (char *) "self",(char *) "weekday", NULL
20550 };
20551
20552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20554 if (SWIG_arg_fail(1)) SWIG_fail;
20555 {
20556 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20557 if (SWIG_arg_fail(2)) SWIG_fail;
20558 }
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 wxDateTime * resultptr;
20568 resultptr = new wxDateTime((wxDateTime &)(result));
20569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 wxDateTime *arg1 = (wxDateTime *) 0 ;
20580 wxDateTime::WeekDay arg2 ;
20581 wxDateTime *result;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char *kwnames[] = {
20585 (char *) "self",(char *) "weekday", NULL
20586 };
20587
20588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20590 if (SWIG_arg_fail(1)) SWIG_fail;
20591 {
20592 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20593 if (SWIG_arg_fail(2)) SWIG_fail;
20594 }
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 {
20598 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20599 result = (wxDateTime *) &_result_ref;
20600 }
20601
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj;
20614 wxDateTime *arg1 = (wxDateTime *) 0 ;
20615 wxDateTime::WeekDay arg2 ;
20616 wxDateTime result;
20617 PyObject * obj0 = 0 ;
20618 PyObject * obj1 = 0 ;
20619 char *kwnames[] = {
20620 (char *) "self",(char *) "weekday", NULL
20621 };
20622
20623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20625 if (SWIG_arg_fail(1)) SWIG_fail;
20626 {
20627 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20628 if (SWIG_arg_fail(2)) SWIG_fail;
20629 }
20630 {
20631 PyThreadState* __tstate = wxPyBeginAllowThreads();
20632 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20633
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 {
20638 wxDateTime * resultptr;
20639 resultptr = new wxDateTime((wxDateTime &)(result));
20640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20641 }
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj;
20650 wxDateTime *arg1 = (wxDateTime *) 0 ;
20651 wxDateTime::WeekDay arg2 ;
20652 int arg3 = (int) 1 ;
20653 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20654 int arg5 = (int) wxDateTime::Inv_Year ;
20655 bool result;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 PyObject * obj2 = 0 ;
20659 PyObject * obj3 = 0 ;
20660 PyObject * obj4 = 0 ;
20661 char *kwnames[] = {
20662 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20663 };
20664
20665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20667 if (SWIG_arg_fail(1)) SWIG_fail;
20668 {
20669 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20670 if (SWIG_arg_fail(2)) SWIG_fail;
20671 }
20672 if (obj2) {
20673 {
20674 arg3 = (int)(SWIG_As_int(obj2));
20675 if (SWIG_arg_fail(3)) SWIG_fail;
20676 }
20677 }
20678 if (obj3) {
20679 {
20680 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20681 if (SWIG_arg_fail(4)) SWIG_fail;
20682 }
20683 }
20684 if (obj4) {
20685 {
20686 arg5 = (int)(SWIG_As_int(obj4));
20687 if (SWIG_arg_fail(5)) SWIG_fail;
20688 }
20689 }
20690 {
20691 PyThreadState* __tstate = wxPyBeginAllowThreads();
20692 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20693
20694 wxPyEndAllowThreads(__tstate);
20695 if (PyErr_Occurred()) SWIG_fail;
20696 }
20697 {
20698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20699 }
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20707 PyObject *resultobj;
20708 wxDateTime *arg1 = (wxDateTime *) 0 ;
20709 wxDateTime::WeekDay arg2 ;
20710 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20711 int arg4 = (int) wxDateTime::Inv_Year ;
20712 bool result;
20713 PyObject * obj0 = 0 ;
20714 PyObject * obj1 = 0 ;
20715 PyObject * obj2 = 0 ;
20716 PyObject * obj3 = 0 ;
20717 char *kwnames[] = {
20718 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20719 };
20720
20721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20723 if (SWIG_arg_fail(1)) SWIG_fail;
20724 {
20725 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20726 if (SWIG_arg_fail(2)) SWIG_fail;
20727 }
20728 if (obj2) {
20729 {
20730 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20731 if (SWIG_arg_fail(3)) SWIG_fail;
20732 }
20733 }
20734 if (obj3) {
20735 {
20736 arg4 = (int)(SWIG_As_int(obj3));
20737 if (SWIG_arg_fail(4)) SWIG_fail;
20738 }
20739 }
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20743
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20757 PyObject *resultobj;
20758 wxDateTime *arg1 = (wxDateTime *) 0 ;
20759 wxDateTime::WeekDay arg2 ;
20760 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20761 int arg4 = (int) wxDateTime::Inv_Year ;
20762 wxDateTime result;
20763 PyObject * obj0 = 0 ;
20764 PyObject * obj1 = 0 ;
20765 PyObject * obj2 = 0 ;
20766 PyObject * obj3 = 0 ;
20767 char *kwnames[] = {
20768 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20773 if (SWIG_arg_fail(1)) SWIG_fail;
20774 {
20775 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20776 if (SWIG_arg_fail(2)) SWIG_fail;
20777 }
20778 if (obj2) {
20779 {
20780 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20781 if (SWIG_arg_fail(3)) SWIG_fail;
20782 }
20783 }
20784 if (obj3) {
20785 {
20786 arg4 = (int)(SWIG_As_int(obj3));
20787 if (SWIG_arg_fail(4)) SWIG_fail;
20788 }
20789 }
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20793
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 {
20798 wxDateTime * resultptr;
20799 resultptr = new wxDateTime((wxDateTime &)(result));
20800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20801 }
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj;
20810 wxDateTime *arg1 = (wxDateTime *) 0 ;
20811 int arg2 ;
20812 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20813 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20814 bool result;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 PyObject * obj2 = 0 ;
20818 PyObject * obj3 = 0 ;
20819 char *kwnames[] = {
20820 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20821 };
20822
20823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(1)) SWIG_fail;
20826 {
20827 arg2 = (int)(SWIG_As_int(obj1));
20828 if (SWIG_arg_fail(2)) SWIG_fail;
20829 }
20830 if (obj2) {
20831 {
20832 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20833 if (SWIG_arg_fail(3)) SWIG_fail;
20834 }
20835 }
20836 if (obj3) {
20837 {
20838 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20839 if (SWIG_arg_fail(4)) SWIG_fail;
20840 }
20841 }
20842 {
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20845
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxDateTime *arg1 = (wxDateTime *) 0 ;
20861 int arg2 ;
20862 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20863 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20864 wxDateTime result;
20865 PyObject * obj0 = 0 ;
20866 PyObject * obj1 = 0 ;
20867 PyObject * obj2 = 0 ;
20868 PyObject * obj3 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 {
20877 arg2 = (int)(SWIG_As_int(obj1));
20878 if (SWIG_arg_fail(2)) SWIG_fail;
20879 }
20880 if (obj2) {
20881 {
20882 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20883 if (SWIG_arg_fail(3)) SWIG_fail;
20884 }
20885 }
20886 if (obj3) {
20887 {
20888 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20889 if (SWIG_arg_fail(4)) SWIG_fail;
20890 }
20891 }
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20895
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 wxDateTime * resultptr;
20901 resultptr = new wxDateTime((wxDateTime &)(result));
20902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj;
20912 int arg1 ;
20913 int arg2 ;
20914 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20915 wxDateTime result;
20916 PyObject * obj0 = 0 ;
20917 PyObject * obj1 = 0 ;
20918 PyObject * obj2 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20924 {
20925 arg1 = (int)(SWIG_As_int(obj0));
20926 if (SWIG_arg_fail(1)) SWIG_fail;
20927 }
20928 {
20929 arg2 = (int)(SWIG_As_int(obj1));
20930 if (SWIG_arg_fail(2)) SWIG_fail;
20931 }
20932 if (obj2) {
20933 {
20934 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20935 if (SWIG_arg_fail(3)) SWIG_fail;
20936 }
20937 }
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20941
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 {
20946 wxDateTime * resultptr;
20947 resultptr = new wxDateTime((wxDateTime &)(result));
20948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20949 }
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20957 PyObject *resultobj;
20958 wxDateTime *arg1 = (wxDateTime *) 0 ;
20959 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20960 int arg3 = (int) wxDateTime::Inv_Year ;
20961 wxDateTime *result;
20962 PyObject * obj0 = 0 ;
20963 PyObject * obj1 = 0 ;
20964 PyObject * obj2 = 0 ;
20965 char *kwnames[] = {
20966 (char *) "self",(char *) "month",(char *) "year", NULL
20967 };
20968
20969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20971 if (SWIG_arg_fail(1)) SWIG_fail;
20972 if (obj1) {
20973 {
20974 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20975 if (SWIG_arg_fail(2)) SWIG_fail;
20976 }
20977 }
20978 if (obj2) {
20979 {
20980 arg3 = (int)(SWIG_As_int(obj2));
20981 if (SWIG_arg_fail(3)) SWIG_fail;
20982 }
20983 }
20984 {
20985 PyThreadState* __tstate = wxPyBeginAllowThreads();
20986 {
20987 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20988 result = (wxDateTime *) &_result_ref;
20989 }
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxDateTime *arg1 = (wxDateTime *) 0 ;
21004 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21005 int arg3 = (int) wxDateTime::Inv_Year ;
21006 wxDateTime result;
21007 PyObject * obj0 = 0 ;
21008 PyObject * obj1 = 0 ;
21009 PyObject * obj2 = 0 ;
21010 char *kwnames[] = {
21011 (char *) "self",(char *) "month",(char *) "year", NULL
21012 };
21013
21014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21016 if (SWIG_arg_fail(1)) SWIG_fail;
21017 if (obj1) {
21018 {
21019 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21020 if (SWIG_arg_fail(2)) SWIG_fail;
21021 }
21022 }
21023 if (obj2) {
21024 {
21025 arg3 = (int)(SWIG_As_int(obj2));
21026 if (SWIG_arg_fail(3)) SWIG_fail;
21027 }
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 {
21037 wxDateTime * resultptr;
21038 resultptr = new wxDateTime((wxDateTime &)(result));
21039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj;
21049 wxDateTime *arg1 = (wxDateTime *) 0 ;
21050 int arg2 ;
21051 wxDateTime *result;
21052 PyObject * obj0 = 0 ;
21053 PyObject * obj1 = 0 ;
21054 char *kwnames[] = {
21055 (char *) "self",(char *) "yday", NULL
21056 };
21057
21058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21060 if (SWIG_arg_fail(1)) SWIG_fail;
21061 {
21062 arg2 = (int)(SWIG_As_int(obj1));
21063 if (SWIG_arg_fail(2)) SWIG_fail;
21064 }
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 {
21068 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21069 result = (wxDateTime *) &_result_ref;
21070 }
21071
21072 wxPyEndAllowThreads(__tstate);
21073 if (PyErr_Occurred()) SWIG_fail;
21074 }
21075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21083 PyObject *resultobj;
21084 wxDateTime *arg1 = (wxDateTime *) 0 ;
21085 int arg2 ;
21086 wxDateTime result;
21087 PyObject * obj0 = 0 ;
21088 PyObject * obj1 = 0 ;
21089 char *kwnames[] = {
21090 (char *) "self",(char *) "yday", NULL
21091 };
21092
21093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21095 if (SWIG_arg_fail(1)) SWIG_fail;
21096 {
21097 arg2 = (int)(SWIG_As_int(obj1));
21098 if (SWIG_arg_fail(2)) SWIG_fail;
21099 }
21100 {
21101 PyThreadState* __tstate = wxPyBeginAllowThreads();
21102 result = (arg1)->GetYearDay(arg2);
21103
21104 wxPyEndAllowThreads(__tstate);
21105 if (PyErr_Occurred()) SWIG_fail;
21106 }
21107 {
21108 wxDateTime * resultptr;
21109 resultptr = new wxDateTime((wxDateTime &)(result));
21110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21111 }
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21119 PyObject *resultobj;
21120 wxDateTime *arg1 = (wxDateTime *) 0 ;
21121 double result;
21122 PyObject * obj0 = 0 ;
21123 char *kwnames[] = {
21124 (char *) "self", NULL
21125 };
21126
21127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21129 if (SWIG_arg_fail(1)) SWIG_fail;
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 result = (double)(arg1)->GetJulianDayNumber();
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 {
21138 resultobj = SWIG_From_double((double)(result));
21139 }
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21147 PyObject *resultobj;
21148 wxDateTime *arg1 = (wxDateTime *) 0 ;
21149 double result;
21150 PyObject * obj0 = 0 ;
21151 char *kwnames[] = {
21152 (char *) "self", NULL
21153 };
21154
21155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21157 if (SWIG_arg_fail(1)) SWIG_fail;
21158 {
21159 PyThreadState* __tstate = wxPyBeginAllowThreads();
21160 result = (double)(arg1)->GetJDN();
21161
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 {
21166 resultobj = SWIG_From_double((double)(result));
21167 }
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21175 PyObject *resultobj;
21176 wxDateTime *arg1 = (wxDateTime *) 0 ;
21177 double result;
21178 PyObject * obj0 = 0 ;
21179 char *kwnames[] = {
21180 (char *) "self", NULL
21181 };
21182
21183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21185 if (SWIG_arg_fail(1)) SWIG_fail;
21186 {
21187 PyThreadState* __tstate = wxPyBeginAllowThreads();
21188 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21189
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 {
21194 resultobj = SWIG_From_double((double)(result));
21195 }
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj;
21204 wxDateTime *arg1 = (wxDateTime *) 0 ;
21205 double result;
21206 PyObject * obj0 = 0 ;
21207 char *kwnames[] = {
21208 (char *) "self", NULL
21209 };
21210
21211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21213 if (SWIG_arg_fail(1)) SWIG_fail;
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 result = (double)(arg1)->GetMJD();
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 resultobj = SWIG_From_double((double)(result));
21223 }
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxDateTime *arg1 = (wxDateTime *) 0 ;
21233 double result;
21234 PyObject * obj0 = 0 ;
21235 char *kwnames[] = {
21236 (char *) "self", NULL
21237 };
21238
21239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21241 if (SWIG_arg_fail(1)) SWIG_fail;
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (double)(arg1)->GetRataDie();
21245
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 {
21250 resultobj = SWIG_From_double((double)(result));
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 wxDateTime *arg1 = (wxDateTime *) 0 ;
21261 wxDateTime::TimeZone *arg2 = 0 ;
21262 bool arg3 = (bool) false ;
21263 wxDateTime result;
21264 bool temp2 = false ;
21265 PyObject * obj0 = 0 ;
21266 PyObject * obj1 = 0 ;
21267 PyObject * obj2 = 0 ;
21268 char *kwnames[] = {
21269 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21270 };
21271
21272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21274 if (SWIG_arg_fail(1)) SWIG_fail;
21275 {
21276 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21277 temp2 = true;
21278 }
21279 if (obj2) {
21280 {
21281 arg3 = (bool)(SWIG_As_bool(obj2));
21282 if (SWIG_arg_fail(3)) SWIG_fail;
21283 }
21284 }
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21288
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 {
21293 wxDateTime * resultptr;
21294 resultptr = new wxDateTime((wxDateTime &)(result));
21295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
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_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxDateTime *arg1 = (wxDateTime *) 0 ;
21312 wxDateTime::TimeZone *arg2 = 0 ;
21313 bool arg3 = (bool) false ;
21314 wxDateTime *result;
21315 bool temp2 = false ;
21316 PyObject * obj0 = 0 ;
21317 PyObject * obj1 = 0 ;
21318 PyObject * obj2 = 0 ;
21319 char *kwnames[] = {
21320 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21321 };
21322
21323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21325 if (SWIG_arg_fail(1)) SWIG_fail;
21326 {
21327 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21328 temp2 = true;
21329 }
21330 if (obj2) {
21331 {
21332 arg3 = (bool)(SWIG_As_bool(obj2));
21333 if (SWIG_arg_fail(3)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 {
21339 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21340 result = (wxDateTime *) &_result_ref;
21341 }
21342
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21347 {
21348 if (temp2) delete arg2;
21349 }
21350 return resultobj;
21351 fail:
21352 {
21353 if (temp2) delete arg2;
21354 }
21355 return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj;
21361 wxDateTime *arg1 = (wxDateTime *) 0 ;
21362 bool arg2 = (bool) false ;
21363 wxDateTime result;
21364 PyObject * obj0 = 0 ;
21365 PyObject * obj1 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "self",(char *) "noDST", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 if (obj1) {
21374 {
21375 arg2 = (bool)(SWIG_As_bool(obj1));
21376 if (SWIG_arg_fail(2)) SWIG_fail;
21377 }
21378 }
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 result = (arg1)->ToGMT(arg2);
21382
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 {
21387 wxDateTime * resultptr;
21388 resultptr = new wxDateTime((wxDateTime &)(result));
21389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj;
21399 wxDateTime *arg1 = (wxDateTime *) 0 ;
21400 bool arg2 = (bool) false ;
21401 wxDateTime *result;
21402 PyObject * obj0 = 0 ;
21403 PyObject * obj1 = 0 ;
21404 char *kwnames[] = {
21405 (char *) "self",(char *) "noDST", NULL
21406 };
21407
21408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21410 if (SWIG_arg_fail(1)) SWIG_fail;
21411 if (obj1) {
21412 {
21413 arg2 = (bool)(SWIG_As_bool(obj1));
21414 if (SWIG_arg_fail(2)) SWIG_fail;
21415 }
21416 }
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 {
21420 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21421 result = (wxDateTime *) &_result_ref;
21422 }
21423
21424 wxPyEndAllowThreads(__tstate);
21425 if (PyErr_Occurred()) SWIG_fail;
21426 }
21427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21428 return resultobj;
21429 fail:
21430 return NULL;
21431 }
21432
21433
21434 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21435 PyObject *resultobj;
21436 wxDateTime *arg1 = (wxDateTime *) 0 ;
21437 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21438 int result;
21439 PyObject * obj0 = 0 ;
21440 PyObject * obj1 = 0 ;
21441 char *kwnames[] = {
21442 (char *) "self",(char *) "country", NULL
21443 };
21444
21445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21447 if (SWIG_arg_fail(1)) SWIG_fail;
21448 if (obj1) {
21449 {
21450 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21451 if (SWIG_arg_fail(2)) SWIG_fail;
21452 }
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21457
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 {
21462 resultobj = SWIG_From_int((int)(result));
21463 }
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj;
21472 wxDateTime *arg1 = (wxDateTime *) 0 ;
21473 bool result;
21474 PyObject * obj0 = 0 ;
21475 char *kwnames[] = {
21476 (char *) "self", NULL
21477 };
21478
21479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21481 if (SWIG_arg_fail(1)) SWIG_fail;
21482 {
21483 PyThreadState* __tstate = wxPyBeginAllowThreads();
21484 result = (bool)((wxDateTime const *)arg1)->IsValid();
21485
21486 wxPyEndAllowThreads(__tstate);
21487 if (PyErr_Occurred()) SWIG_fail;
21488 }
21489 {
21490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21491 }
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21499 PyObject *resultobj;
21500 wxDateTime *arg1 = (wxDateTime *) 0 ;
21501 time_t result;
21502 PyObject * obj0 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 {
21518 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21519 }
21520 return resultobj;
21521 fail:
21522 return NULL;
21523 }
21524
21525
21526 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21527 PyObject *resultobj;
21528 wxDateTime *arg1 = (wxDateTime *) 0 ;
21529 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21530 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21531 int result;
21532 bool temp2 = false ;
21533 PyObject * obj0 = 0 ;
21534 PyObject * obj1 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "self",(char *) "tz", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21541 if (SWIG_arg_fail(1)) SWIG_fail;
21542 if (obj1) {
21543 {
21544 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21545 temp2 = true;
21546 }
21547 }
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 {
21556 resultobj = SWIG_From_int((int)(result));
21557 }
21558 {
21559 if (temp2) delete arg2;
21560 }
21561 return resultobj;
21562 fail:
21563 {
21564 if (temp2) delete arg2;
21565 }
21566 return NULL;
21567 }
21568
21569
21570 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21571 PyObject *resultobj;
21572 wxDateTime *arg1 = (wxDateTime *) 0 ;
21573 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21574 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21575 wxDateTime::Month result;
21576 bool temp2 = false ;
21577 PyObject * obj0 = 0 ;
21578 PyObject * obj1 = 0 ;
21579 char *kwnames[] = {
21580 (char *) "self",(char *) "tz", NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21585 if (SWIG_arg_fail(1)) SWIG_fail;
21586 if (obj1) {
21587 {
21588 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21589 temp2 = true;
21590 }
21591 }
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_From_int((result));
21600 {
21601 if (temp2) delete arg2;
21602 }
21603 return resultobj;
21604 fail:
21605 {
21606 if (temp2) delete arg2;
21607 }
21608 return NULL;
21609 }
21610
21611
21612 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj;
21614 wxDateTime *arg1 = (wxDateTime *) 0 ;
21615 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21616 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21617 int result;
21618 bool temp2 = false ;
21619 PyObject * obj0 = 0 ;
21620 PyObject * obj1 = 0 ;
21621 char *kwnames[] = {
21622 (char *) "self",(char *) "tz", NULL
21623 };
21624
21625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21627 if (SWIG_arg_fail(1)) SWIG_fail;
21628 if (obj1) {
21629 {
21630 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21631 temp2 = true;
21632 }
21633 }
21634 {
21635 PyThreadState* __tstate = wxPyBeginAllowThreads();
21636 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21637
21638 wxPyEndAllowThreads(__tstate);
21639 if (PyErr_Occurred()) SWIG_fail;
21640 }
21641 {
21642 resultobj = SWIG_From_int((int)(result));
21643 }
21644 {
21645 if (temp2) delete arg2;
21646 }
21647 return resultobj;
21648 fail:
21649 {
21650 if (temp2) delete arg2;
21651 }
21652 return NULL;
21653 }
21654
21655
21656 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21657 PyObject *resultobj;
21658 wxDateTime *arg1 = (wxDateTime *) 0 ;
21659 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21660 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21661 wxDateTime::WeekDay result;
21662 bool temp2 = false ;
21663 PyObject * obj0 = 0 ;
21664 PyObject * obj1 = 0 ;
21665 char *kwnames[] = {
21666 (char *) "self",(char *) "tz", NULL
21667 };
21668
21669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21671 if (SWIG_arg_fail(1)) SWIG_fail;
21672 if (obj1) {
21673 {
21674 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21675 temp2 = true;
21676 }
21677 }
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21681
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 resultobj = SWIG_From_int((result));
21686 {
21687 if (temp2) delete arg2;
21688 }
21689 return resultobj;
21690 fail:
21691 {
21692 if (temp2) delete arg2;
21693 }
21694 return NULL;
21695 }
21696
21697
21698 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj;
21700 wxDateTime *arg1 = (wxDateTime *) 0 ;
21701 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21702 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21703 int result;
21704 bool temp2 = false ;
21705 PyObject * obj0 = 0 ;
21706 PyObject * obj1 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "self",(char *) "tz", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21713 if (SWIG_arg_fail(1)) SWIG_fail;
21714 if (obj1) {
21715 {
21716 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21717 temp2 = true;
21718 }
21719 }
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 {
21728 resultobj = SWIG_From_int((int)(result));
21729 }
21730 {
21731 if (temp2) delete arg2;
21732 }
21733 return resultobj;
21734 fail:
21735 {
21736 if (temp2) delete arg2;
21737 }
21738 return NULL;
21739 }
21740
21741
21742 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21743 PyObject *resultobj;
21744 wxDateTime *arg1 = (wxDateTime *) 0 ;
21745 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21746 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21747 int result;
21748 bool temp2 = false ;
21749 PyObject * obj0 = 0 ;
21750 PyObject * obj1 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "self",(char *) "tz", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 if (obj1) {
21759 {
21760 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21761 temp2 = true;
21762 }
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 {
21772 resultobj = SWIG_From_int((int)(result));
21773 }
21774 {
21775 if (temp2) delete arg2;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp2) delete arg2;
21781 }
21782 return NULL;
21783 }
21784
21785
21786 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 wxDateTime *arg1 = (wxDateTime *) 0 ;
21789 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21790 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21791 int result;
21792 bool temp2 = false ;
21793 PyObject * obj0 = 0 ;
21794 PyObject * obj1 = 0 ;
21795 char *kwnames[] = {
21796 (char *) "self",(char *) "tz", NULL
21797 };
21798
21799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21801 if (SWIG_arg_fail(1)) SWIG_fail;
21802 if (obj1) {
21803 {
21804 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21805 temp2 = true;
21806 }
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21811
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 {
21816 resultobj = SWIG_From_int((int)(result));
21817 }
21818 {
21819 if (temp2) delete arg2;
21820 }
21821 return resultobj;
21822 fail:
21823 {
21824 if (temp2) delete arg2;
21825 }
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxDateTime *arg1 = (wxDateTime *) 0 ;
21833 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21834 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21835 int result;
21836 bool temp2 = false ;
21837 PyObject * obj0 = 0 ;
21838 PyObject * obj1 = 0 ;
21839 char *kwnames[] = {
21840 (char *) "self",(char *) "tz", NULL
21841 };
21842
21843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21845 if (SWIG_arg_fail(1)) SWIG_fail;
21846 if (obj1) {
21847 {
21848 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21849 temp2 = true;
21850 }
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21855
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 {
21860 resultobj = SWIG_From_int((int)(result));
21861 }
21862 {
21863 if (temp2) delete arg2;
21864 }
21865 return resultobj;
21866 fail:
21867 {
21868 if (temp2) delete arg2;
21869 }
21870 return NULL;
21871 }
21872
21873
21874 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21875 PyObject *resultobj;
21876 wxDateTime *arg1 = (wxDateTime *) 0 ;
21877 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21878 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21879 int result;
21880 bool temp2 = false ;
21881 PyObject * obj0 = 0 ;
21882 PyObject * obj1 = 0 ;
21883 char *kwnames[] = {
21884 (char *) "self",(char *) "tz", NULL
21885 };
21886
21887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21889 if (SWIG_arg_fail(1)) SWIG_fail;
21890 if (obj1) {
21891 {
21892 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21893 temp2 = true;
21894 }
21895 }
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 {
21904 resultobj = SWIG_From_int((int)(result));
21905 }
21906 {
21907 if (temp2) delete arg2;
21908 }
21909 return resultobj;
21910 fail:
21911 {
21912 if (temp2) delete arg2;
21913 }
21914 return NULL;
21915 }
21916
21917
21918 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj;
21920 wxDateTime *arg1 = (wxDateTime *) 0 ;
21921 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21922 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21923 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21924 int result;
21925 bool temp3 = false ;
21926 PyObject * obj0 = 0 ;
21927 PyObject * obj1 = 0 ;
21928 PyObject * obj2 = 0 ;
21929 char *kwnames[] = {
21930 (char *) "self",(char *) "flags",(char *) "tz", NULL
21931 };
21932
21933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21935 if (SWIG_arg_fail(1)) SWIG_fail;
21936 if (obj1) {
21937 {
21938 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21939 if (SWIG_arg_fail(2)) SWIG_fail;
21940 }
21941 }
21942 if (obj2) {
21943 {
21944 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21945 temp3 = true;
21946 }
21947 }
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = SWIG_From_int((int)(result));
21957 }
21958 {
21959 if (temp3) delete arg3;
21960 }
21961 return resultobj;
21962 fail:
21963 {
21964 if (temp3) delete arg3;
21965 }
21966 return NULL;
21967 }
21968
21969
21970 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj;
21972 wxDateTime *arg1 = (wxDateTime *) 0 ;
21973 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21974 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21975 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21976 int result;
21977 bool temp3 = false ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 PyObject * obj2 = 0 ;
21981 char *kwnames[] = {
21982 (char *) "self",(char *) "flags",(char *) "tz", NULL
21983 };
21984
21985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21987 if (SWIG_arg_fail(1)) SWIG_fail;
21988 if (obj1) {
21989 {
21990 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21991 if (SWIG_arg_fail(2)) SWIG_fail;
21992 }
21993 }
21994 if (obj2) {
21995 {
21996 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21997 temp3 = true;
21998 }
21999 }
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22003
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 {
22008 resultobj = SWIG_From_int((int)(result));
22009 }
22010 {
22011 if (temp3) delete arg3;
22012 }
22013 return resultobj;
22014 fail:
22015 {
22016 if (temp3) delete arg3;
22017 }
22018 return NULL;
22019 }
22020
22021
22022 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22023 PyObject *resultobj;
22024 wxDateTime *arg1 = (wxDateTime *) 0 ;
22025 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22026 bool result;
22027 PyObject * obj0 = 0 ;
22028 PyObject * obj1 = 0 ;
22029 char *kwnames[] = {
22030 (char *) "self",(char *) "country", NULL
22031 };
22032
22033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22035 if (SWIG_arg_fail(1)) SWIG_fail;
22036 if (obj1) {
22037 {
22038 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22039 if (SWIG_arg_fail(2)) SWIG_fail;
22040 }
22041 }
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22045
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 {
22050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22051 }
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22059 PyObject *resultobj;
22060 wxDateTime *arg1 = (wxDateTime *) 0 ;
22061 wxDateTime *arg2 = 0 ;
22062 bool result;
22063 PyObject * obj0 = 0 ;
22064 PyObject * obj1 = 0 ;
22065 char *kwnames[] = {
22066 (char *) "self",(char *) "datetime", NULL
22067 };
22068
22069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22071 if (SWIG_arg_fail(1)) SWIG_fail;
22072 {
22073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22074 if (SWIG_arg_fail(2)) SWIG_fail;
22075 if (arg2 == NULL) {
22076 SWIG_null_ref("wxDateTime");
22077 }
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 }
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22083
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22097 PyObject *resultobj;
22098 wxDateTime *arg1 = (wxDateTime *) 0 ;
22099 wxDateTime *arg2 = 0 ;
22100 bool result;
22101 PyObject * obj0 = 0 ;
22102 PyObject * obj1 = 0 ;
22103 char *kwnames[] = {
22104 (char *) "self",(char *) "datetime", NULL
22105 };
22106
22107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(1)) SWIG_fail;
22110 {
22111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(2)) SWIG_fail;
22113 if (arg2 == NULL) {
22114 SWIG_null_ref("wxDateTime");
22115 }
22116 if (SWIG_arg_fail(2)) SWIG_fail;
22117 }
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22121
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 {
22126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22127 }
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxDateTime *arg1 = (wxDateTime *) 0 ;
22137 wxDateTime *arg2 = 0 ;
22138 bool result;
22139 PyObject * obj0 = 0 ;
22140 PyObject * obj1 = 0 ;
22141 char *kwnames[] = {
22142 (char *) "self",(char *) "datetime", NULL
22143 };
22144
22145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22147 if (SWIG_arg_fail(1)) SWIG_fail;
22148 {
22149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 if (arg2 == NULL) {
22152 SWIG_null_ref("wxDateTime");
22153 }
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 }
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22159
22160 wxPyEndAllowThreads(__tstate);
22161 if (PyErr_Occurred()) SWIG_fail;
22162 }
22163 {
22164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj;
22174 wxDateTime *arg1 = (wxDateTime *) 0 ;
22175 wxDateTime *arg2 = 0 ;
22176 wxDateTime *arg3 = 0 ;
22177 bool result;
22178 PyObject * obj0 = 0 ;
22179 PyObject * obj1 = 0 ;
22180 PyObject * obj2 = 0 ;
22181 char *kwnames[] = {
22182 (char *) "self",(char *) "t1",(char *) "t2", NULL
22183 };
22184
22185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22187 if (SWIG_arg_fail(1)) SWIG_fail;
22188 {
22189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(2)) SWIG_fail;
22191 if (arg2 == NULL) {
22192 SWIG_null_ref("wxDateTime");
22193 }
22194 if (SWIG_arg_fail(2)) SWIG_fail;
22195 }
22196 {
22197 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22198 if (SWIG_arg_fail(3)) SWIG_fail;
22199 if (arg3 == NULL) {
22200 SWIG_null_ref("wxDateTime");
22201 }
22202 if (SWIG_arg_fail(3)) SWIG_fail;
22203 }
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22207
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 {
22212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22213 }
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22221 PyObject *resultobj;
22222 wxDateTime *arg1 = (wxDateTime *) 0 ;
22223 wxDateTime *arg2 = 0 ;
22224 wxDateTime *arg3 = 0 ;
22225 bool result;
22226 PyObject * obj0 = 0 ;
22227 PyObject * obj1 = 0 ;
22228 PyObject * obj2 = 0 ;
22229 char *kwnames[] = {
22230 (char *) "self",(char *) "t1",(char *) "t2", NULL
22231 };
22232
22233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22235 if (SWIG_arg_fail(1)) SWIG_fail;
22236 {
22237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(2)) SWIG_fail;
22239 if (arg2 == NULL) {
22240 SWIG_null_ref("wxDateTime");
22241 }
22242 if (SWIG_arg_fail(2)) SWIG_fail;
22243 }
22244 {
22245 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22246 if (SWIG_arg_fail(3)) SWIG_fail;
22247 if (arg3 == NULL) {
22248 SWIG_null_ref("wxDateTime");
22249 }
22250 if (SWIG_arg_fail(3)) SWIG_fail;
22251 }
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22269 PyObject *resultobj;
22270 wxDateTime *arg1 = (wxDateTime *) 0 ;
22271 wxDateTime *arg2 = 0 ;
22272 bool result;
22273 PyObject * obj0 = 0 ;
22274 PyObject * obj1 = 0 ;
22275 char *kwnames[] = {
22276 (char *) "self",(char *) "dt", NULL
22277 };
22278
22279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22281 if (SWIG_arg_fail(1)) SWIG_fail;
22282 {
22283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22284 if (SWIG_arg_fail(2)) SWIG_fail;
22285 if (arg2 == NULL) {
22286 SWIG_null_ref("wxDateTime");
22287 }
22288 if (SWIG_arg_fail(2)) SWIG_fail;
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 {
22298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22299 }
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22307 PyObject *resultobj;
22308 wxDateTime *arg1 = (wxDateTime *) 0 ;
22309 wxDateTime *arg2 = 0 ;
22310 bool result;
22311 PyObject * obj0 = 0 ;
22312 PyObject * obj1 = 0 ;
22313 char *kwnames[] = {
22314 (char *) "self",(char *) "dt", NULL
22315 };
22316
22317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22319 if (SWIG_arg_fail(1)) SWIG_fail;
22320 {
22321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 if (arg2 == NULL) {
22324 SWIG_null_ref("wxDateTime");
22325 }
22326 if (SWIG_arg_fail(2)) SWIG_fail;
22327 }
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj;
22346 wxDateTime *arg1 = (wxDateTime *) 0 ;
22347 wxDateTime *arg2 = 0 ;
22348 wxTimeSpan *arg3 = 0 ;
22349 bool result;
22350 PyObject * obj0 = 0 ;
22351 PyObject * obj1 = 0 ;
22352 PyObject * obj2 = 0 ;
22353 char *kwnames[] = {
22354 (char *) "self",(char *) "dt",(char *) "ts", NULL
22355 };
22356
22357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22359 if (SWIG_arg_fail(1)) SWIG_fail;
22360 {
22361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22362 if (SWIG_arg_fail(2)) SWIG_fail;
22363 if (arg2 == NULL) {
22364 SWIG_null_ref("wxDateTime");
22365 }
22366 if (SWIG_arg_fail(2)) SWIG_fail;
22367 }
22368 {
22369 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22370 if (SWIG_arg_fail(3)) SWIG_fail;
22371 if (arg3 == NULL) {
22372 SWIG_null_ref("wxTimeSpan");
22373 }
22374 if (SWIG_arg_fail(3)) SWIG_fail;
22375 }
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22379
22380 wxPyEndAllowThreads(__tstate);
22381 if (PyErr_Occurred()) SWIG_fail;
22382 }
22383 {
22384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22385 }
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22393 PyObject *resultobj;
22394 wxDateTime *arg1 = (wxDateTime *) 0 ;
22395 wxTimeSpan *arg2 = 0 ;
22396 wxDateTime *result;
22397 PyObject * obj0 = 0 ;
22398 PyObject * obj1 = 0 ;
22399 char *kwnames[] = {
22400 (char *) "self",(char *) "diff", NULL
22401 };
22402
22403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(1)) SWIG_fail;
22406 {
22407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(2)) SWIG_fail;
22409 if (arg2 == NULL) {
22410 SWIG_null_ref("wxTimeSpan");
22411 }
22412 if (SWIG_arg_fail(2)) SWIG_fail;
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 {
22417 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22418 result = (wxDateTime *) &_result_ref;
22419 }
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxDateTime *arg1 = (wxDateTime *) 0 ;
22434 wxDateSpan *arg2 = 0 ;
22435 wxDateTime *result;
22436 PyObject * obj0 = 0 ;
22437 PyObject * obj1 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self",(char *) "diff", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22447 if (SWIG_arg_fail(2)) SWIG_fail;
22448 if (arg2 == NULL) {
22449 SWIG_null_ref("wxDateSpan");
22450 }
22451 if (SWIG_arg_fail(2)) SWIG_fail;
22452 }
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 {
22456 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22457 result = (wxDateTime *) &_result_ref;
22458 }
22459
22460 wxPyEndAllowThreads(__tstate);
22461 if (PyErr_Occurred()) SWIG_fail;
22462 }
22463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22471 PyObject *resultobj;
22472 wxDateTime *arg1 = (wxDateTime *) 0 ;
22473 wxTimeSpan *arg2 = 0 ;
22474 wxDateTime *result;
22475 PyObject * obj0 = 0 ;
22476 PyObject * obj1 = 0 ;
22477 char *kwnames[] = {
22478 (char *) "self",(char *) "diff", NULL
22479 };
22480
22481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(1)) SWIG_fail;
22484 {
22485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22486 if (SWIG_arg_fail(2)) SWIG_fail;
22487 if (arg2 == NULL) {
22488 SWIG_null_ref("wxTimeSpan");
22489 }
22490 if (SWIG_arg_fail(2)) SWIG_fail;
22491 }
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 {
22495 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22496 result = (wxDateTime *) &_result_ref;
22497 }
22498
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj;
22511 wxDateTime *arg1 = (wxDateTime *) 0 ;
22512 wxDateSpan *arg2 = 0 ;
22513 wxDateTime *result;
22514 PyObject * obj0 = 0 ;
22515 PyObject * obj1 = 0 ;
22516 char *kwnames[] = {
22517 (char *) "self",(char *) "diff", NULL
22518 };
22519
22520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22522 if (SWIG_arg_fail(1)) SWIG_fail;
22523 {
22524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(2)) SWIG_fail;
22526 if (arg2 == NULL) {
22527 SWIG_null_ref("wxDateSpan");
22528 }
22529 if (SWIG_arg_fail(2)) SWIG_fail;
22530 }
22531 {
22532 PyThreadState* __tstate = wxPyBeginAllowThreads();
22533 {
22534 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22535 result = (wxDateTime *) &_result_ref;
22536 }
22537
22538 wxPyEndAllowThreads(__tstate);
22539 if (PyErr_Occurred()) SWIG_fail;
22540 }
22541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22542 return resultobj;
22543 fail:
22544 return NULL;
22545 }
22546
22547
22548 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22549 PyObject *resultobj;
22550 wxDateTime *arg1 = (wxDateTime *) 0 ;
22551 wxDateTime *arg2 = 0 ;
22552 wxTimeSpan result;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555 char *kwnames[] = {
22556 (char *) "self",(char *) "dt", NULL
22557 };
22558
22559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22561 if (SWIG_arg_fail(1)) SWIG_fail;
22562 {
22563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22564 if (SWIG_arg_fail(2)) SWIG_fail;
22565 if (arg2 == NULL) {
22566 SWIG_null_ref("wxDateTime");
22567 }
22568 if (SWIG_arg_fail(2)) SWIG_fail;
22569 }
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22573
22574 wxPyEndAllowThreads(__tstate);
22575 if (PyErr_Occurred()) SWIG_fail;
22576 }
22577 {
22578 wxTimeSpan * resultptr;
22579 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22581 }
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22589 PyObject *resultobj;
22590 wxDateTime *arg1 = (wxDateTime *) 0 ;
22591 wxTimeSpan *arg2 = 0 ;
22592 wxDateTime *result;
22593 PyObject * obj0 = 0 ;
22594 PyObject * obj1 = 0 ;
22595
22596 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22598 if (SWIG_arg_fail(1)) SWIG_fail;
22599 {
22600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 if (arg2 == NULL) {
22603 SWIG_null_ref("wxTimeSpan");
22604 }
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 }
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 {
22610 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22611 result = (wxDateTime *) &_result_ref;
22612 }
22613
22614 wxPyEndAllowThreads(__tstate);
22615 if (PyErr_Occurred()) SWIG_fail;
22616 }
22617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22625 PyObject *resultobj;
22626 wxDateTime *arg1 = (wxDateTime *) 0 ;
22627 wxDateSpan *arg2 = 0 ;
22628 wxDateTime *result;
22629 PyObject * obj0 = 0 ;
22630 PyObject * obj1 = 0 ;
22631
22632 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22634 if (SWIG_arg_fail(1)) SWIG_fail;
22635 {
22636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22637 if (SWIG_arg_fail(2)) SWIG_fail;
22638 if (arg2 == NULL) {
22639 SWIG_null_ref("wxDateSpan");
22640 }
22641 if (SWIG_arg_fail(2)) SWIG_fail;
22642 }
22643 {
22644 PyThreadState* __tstate = wxPyBeginAllowThreads();
22645 {
22646 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22647 result = (wxDateTime *) &_result_ref;
22648 }
22649
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22661 int argc;
22662 PyObject *argv[3];
22663 int ii;
22664
22665 argc = PyObject_Length(args);
22666 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22667 argv[ii] = PyTuple_GetItem(args,ii);
22668 }
22669 if (argc == 2) {
22670 int _v;
22671 {
22672 void *ptr;
22673 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22674 _v = 0;
22675 PyErr_Clear();
22676 } else {
22677 _v = 1;
22678 }
22679 }
22680 if (_v) {
22681 {
22682 void *ptr = 0;
22683 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22684 _v = 0;
22685 PyErr_Clear();
22686 } else {
22687 _v = (ptr != 0);
22688 }
22689 }
22690 if (_v) {
22691 return _wrap_DateTime___iadd____SWIG_0(self,args);
22692 }
22693 }
22694 }
22695 if (argc == 2) {
22696 int _v;
22697 {
22698 void *ptr;
22699 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22700 _v = 0;
22701 PyErr_Clear();
22702 } else {
22703 _v = 1;
22704 }
22705 }
22706 if (_v) {
22707 {
22708 void *ptr = 0;
22709 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22710 _v = 0;
22711 PyErr_Clear();
22712 } else {
22713 _v = (ptr != 0);
22714 }
22715 }
22716 if (_v) {
22717 return _wrap_DateTime___iadd____SWIG_1(self,args);
22718 }
22719 }
22720 }
22721
22722 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22723 return NULL;
22724 }
22725
22726
22727 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22728 PyObject *resultobj;
22729 wxDateTime *arg1 = (wxDateTime *) 0 ;
22730 wxTimeSpan *arg2 = 0 ;
22731 wxDateTime *result;
22732 PyObject * obj0 = 0 ;
22733 PyObject * obj1 = 0 ;
22734
22735 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22737 if (SWIG_arg_fail(1)) SWIG_fail;
22738 {
22739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22740 if (SWIG_arg_fail(2)) SWIG_fail;
22741 if (arg2 == NULL) {
22742 SWIG_null_ref("wxTimeSpan");
22743 }
22744 if (SWIG_arg_fail(2)) SWIG_fail;
22745 }
22746 {
22747 PyThreadState* __tstate = wxPyBeginAllowThreads();
22748 {
22749 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22750 result = (wxDateTime *) &_result_ref;
22751 }
22752
22753 wxPyEndAllowThreads(__tstate);
22754 if (PyErr_Occurred()) SWIG_fail;
22755 }
22756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22757 return resultobj;
22758 fail:
22759 return NULL;
22760 }
22761
22762
22763 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22764 PyObject *resultobj;
22765 wxDateTime *arg1 = (wxDateTime *) 0 ;
22766 wxDateSpan *arg2 = 0 ;
22767 wxDateTime *result;
22768 PyObject * obj0 = 0 ;
22769 PyObject * obj1 = 0 ;
22770
22771 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22773 if (SWIG_arg_fail(1)) SWIG_fail;
22774 {
22775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22776 if (SWIG_arg_fail(2)) SWIG_fail;
22777 if (arg2 == NULL) {
22778 SWIG_null_ref("wxDateSpan");
22779 }
22780 if (SWIG_arg_fail(2)) SWIG_fail;
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 {
22785 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22786 result = (wxDateTime *) &_result_ref;
22787 }
22788
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22800 int argc;
22801 PyObject *argv[3];
22802 int ii;
22803
22804 argc = PyObject_Length(args);
22805 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22806 argv[ii] = PyTuple_GetItem(args,ii);
22807 }
22808 if (argc == 2) {
22809 int _v;
22810 {
22811 void *ptr;
22812 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22813 _v = 0;
22814 PyErr_Clear();
22815 } else {
22816 _v = 1;
22817 }
22818 }
22819 if (_v) {
22820 {
22821 void *ptr = 0;
22822 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22823 _v = 0;
22824 PyErr_Clear();
22825 } else {
22826 _v = (ptr != 0);
22827 }
22828 }
22829 if (_v) {
22830 return _wrap_DateTime___isub____SWIG_0(self,args);
22831 }
22832 }
22833 }
22834 if (argc == 2) {
22835 int _v;
22836 {
22837 void *ptr;
22838 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22839 _v = 0;
22840 PyErr_Clear();
22841 } else {
22842 _v = 1;
22843 }
22844 }
22845 if (_v) {
22846 {
22847 void *ptr = 0;
22848 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22849 _v = 0;
22850 PyErr_Clear();
22851 } else {
22852 _v = (ptr != 0);
22853 }
22854 }
22855 if (_v) {
22856 return _wrap_DateTime___isub____SWIG_1(self,args);
22857 }
22858 }
22859 }
22860
22861 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22867 PyObject *resultobj;
22868 wxDateTime *arg1 = (wxDateTime *) 0 ;
22869 wxTimeSpan *arg2 = 0 ;
22870 wxDateTime result;
22871 PyObject * obj0 = 0 ;
22872 PyObject * obj1 = 0 ;
22873
22874 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22876 if (SWIG_arg_fail(1)) SWIG_fail;
22877 {
22878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22879 if (SWIG_arg_fail(2)) SWIG_fail;
22880 if (arg2 == NULL) {
22881 SWIG_null_ref("wxTimeSpan");
22882 }
22883 if (SWIG_arg_fail(2)) SWIG_fail;
22884 }
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22888
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 wxDateTime * resultptr;
22894 resultptr = new wxDateTime((wxDateTime &)(result));
22895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22896 }
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22904 PyObject *resultobj;
22905 wxDateTime *arg1 = (wxDateTime *) 0 ;
22906 wxDateSpan *arg2 = 0 ;
22907 wxDateTime result;
22908 PyObject * obj0 = 0 ;
22909 PyObject * obj1 = 0 ;
22910
22911 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22913 if (SWIG_arg_fail(1)) SWIG_fail;
22914 {
22915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22916 if (SWIG_arg_fail(2)) SWIG_fail;
22917 if (arg2 == NULL) {
22918 SWIG_null_ref("wxDateSpan");
22919 }
22920 if (SWIG_arg_fail(2)) SWIG_fail;
22921 }
22922 {
22923 PyThreadState* __tstate = wxPyBeginAllowThreads();
22924 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22925
22926 wxPyEndAllowThreads(__tstate);
22927 if (PyErr_Occurred()) SWIG_fail;
22928 }
22929 {
22930 wxDateTime * resultptr;
22931 resultptr = new wxDateTime((wxDateTime &)(result));
22932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22933 }
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22941 int argc;
22942 PyObject *argv[3];
22943 int ii;
22944
22945 argc = PyObject_Length(args);
22946 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22947 argv[ii] = PyTuple_GetItem(args,ii);
22948 }
22949 if (argc == 2) {
22950 int _v;
22951 {
22952 void *ptr;
22953 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22954 _v = 0;
22955 PyErr_Clear();
22956 } else {
22957 _v = 1;
22958 }
22959 }
22960 if (_v) {
22961 {
22962 void *ptr = 0;
22963 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22964 _v = 0;
22965 PyErr_Clear();
22966 } else {
22967 _v = (ptr != 0);
22968 }
22969 }
22970 if (_v) {
22971 return _wrap_DateTime___add____SWIG_0(self,args);
22972 }
22973 }
22974 }
22975 if (argc == 2) {
22976 int _v;
22977 {
22978 void *ptr;
22979 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22980 _v = 0;
22981 PyErr_Clear();
22982 } else {
22983 _v = 1;
22984 }
22985 }
22986 if (_v) {
22987 {
22988 void *ptr = 0;
22989 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22990 _v = 0;
22991 PyErr_Clear();
22992 } else {
22993 _v = (ptr != 0);
22994 }
22995 }
22996 if (_v) {
22997 return _wrap_DateTime___add____SWIG_1(self,args);
22998 }
22999 }
23000 }
23001
23002 Py_INCREF(Py_NotImplemented);
23003 return Py_NotImplemented;
23004 }
23005
23006
23007 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23008 PyObject *resultobj;
23009 wxDateTime *arg1 = (wxDateTime *) 0 ;
23010 wxDateTime *arg2 = 0 ;
23011 wxTimeSpan result;
23012 PyObject * obj0 = 0 ;
23013 PyObject * obj1 = 0 ;
23014
23015 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23017 if (SWIG_arg_fail(1)) SWIG_fail;
23018 {
23019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23020 if (SWIG_arg_fail(2)) SWIG_fail;
23021 if (arg2 == NULL) {
23022 SWIG_null_ref("wxDateTime");
23023 }
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 }
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23029
23030 wxPyEndAllowThreads(__tstate);
23031 if (PyErr_Occurred()) SWIG_fail;
23032 }
23033 {
23034 wxTimeSpan * resultptr;
23035 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23037 }
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23045 PyObject *resultobj;
23046 wxDateTime *arg1 = (wxDateTime *) 0 ;
23047 wxTimeSpan *arg2 = 0 ;
23048 wxDateTime result;
23049 PyObject * obj0 = 0 ;
23050 PyObject * obj1 = 0 ;
23051
23052 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 {
23056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23057 if (SWIG_arg_fail(2)) SWIG_fail;
23058 if (arg2 == NULL) {
23059 SWIG_null_ref("wxTimeSpan");
23060 }
23061 if (SWIG_arg_fail(2)) SWIG_fail;
23062 }
23063 {
23064 PyThreadState* __tstate = wxPyBeginAllowThreads();
23065 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23066
23067 wxPyEndAllowThreads(__tstate);
23068 if (PyErr_Occurred()) SWIG_fail;
23069 }
23070 {
23071 wxDateTime * resultptr;
23072 resultptr = new wxDateTime((wxDateTime &)(result));
23073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23082 PyObject *resultobj;
23083 wxDateTime *arg1 = (wxDateTime *) 0 ;
23084 wxDateSpan *arg2 = 0 ;
23085 wxDateTime result;
23086 PyObject * obj0 = 0 ;
23087 PyObject * obj1 = 0 ;
23088
23089 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(1)) SWIG_fail;
23092 {
23093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23094 if (SWIG_arg_fail(2)) SWIG_fail;
23095 if (arg2 == NULL) {
23096 SWIG_null_ref("wxDateSpan");
23097 }
23098 if (SWIG_arg_fail(2)) SWIG_fail;
23099 }
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23103
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 {
23108 wxDateTime * resultptr;
23109 resultptr = new wxDateTime((wxDateTime &)(result));
23110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23111 }
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23119 int argc;
23120 PyObject *argv[3];
23121 int ii;
23122
23123 argc = PyObject_Length(args);
23124 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23125 argv[ii] = PyTuple_GetItem(args,ii);
23126 }
23127 if (argc == 2) {
23128 int _v;
23129 {
23130 void *ptr;
23131 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23132 _v = 0;
23133 PyErr_Clear();
23134 } else {
23135 _v = 1;
23136 }
23137 }
23138 if (_v) {
23139 {
23140 void *ptr = 0;
23141 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23142 _v = 0;
23143 PyErr_Clear();
23144 } else {
23145 _v = (ptr != 0);
23146 }
23147 }
23148 if (_v) {
23149 return _wrap_DateTime___sub____SWIG_0(self,args);
23150 }
23151 }
23152 }
23153 if (argc == 2) {
23154 int _v;
23155 {
23156 void *ptr;
23157 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23158 _v = 0;
23159 PyErr_Clear();
23160 } else {
23161 _v = 1;
23162 }
23163 }
23164 if (_v) {
23165 {
23166 void *ptr = 0;
23167 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23168 _v = 0;
23169 PyErr_Clear();
23170 } else {
23171 _v = (ptr != 0);
23172 }
23173 }
23174 if (_v) {
23175 return _wrap_DateTime___sub____SWIG_1(self,args);
23176 }
23177 }
23178 }
23179 if (argc == 2) {
23180 int _v;
23181 {
23182 void *ptr;
23183 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23184 _v = 0;
23185 PyErr_Clear();
23186 } else {
23187 _v = 1;
23188 }
23189 }
23190 if (_v) {
23191 {
23192 void *ptr = 0;
23193 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23194 _v = 0;
23195 PyErr_Clear();
23196 } else {
23197 _v = (ptr != 0);
23198 }
23199 }
23200 if (_v) {
23201 return _wrap_DateTime___sub____SWIG_2(self,args);
23202 }
23203 }
23204 }
23205
23206 Py_INCREF(Py_NotImplemented);
23207 return Py_NotImplemented;
23208 }
23209
23210
23211 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23212 PyObject *resultobj;
23213 wxDateTime *arg1 = (wxDateTime *) 0 ;
23214 wxDateTime *arg2 = (wxDateTime *) 0 ;
23215 bool result;
23216 PyObject * obj0 = 0 ;
23217 PyObject * obj1 = 0 ;
23218 char *kwnames[] = {
23219 (char *) "self",(char *) "other", NULL
23220 };
23221
23222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23224 if (SWIG_arg_fail(1)) SWIG_fail;
23225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23226 if (SWIG_arg_fail(2)) SWIG_fail;
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23230
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 {
23235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23236 }
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23244 PyObject *resultobj;
23245 wxDateTime *arg1 = (wxDateTime *) 0 ;
23246 wxDateTime *arg2 = (wxDateTime *) 0 ;
23247 bool result;
23248 PyObject * obj0 = 0 ;
23249 PyObject * obj1 = 0 ;
23250 char *kwnames[] = {
23251 (char *) "self",(char *) "other", NULL
23252 };
23253
23254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23258 if (SWIG_arg_fail(2)) SWIG_fail;
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23262
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 {
23267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23268 }
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj;
23277 wxDateTime *arg1 = (wxDateTime *) 0 ;
23278 wxDateTime *arg2 = (wxDateTime *) 0 ;
23279 bool result;
23280 PyObject * obj0 = 0 ;
23281 PyObject * obj1 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "self",(char *) "other", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23290 if (SWIG_arg_fail(2)) SWIG_fail;
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23308 PyObject *resultobj;
23309 wxDateTime *arg1 = (wxDateTime *) 0 ;
23310 wxDateTime *arg2 = (wxDateTime *) 0 ;
23311 bool result;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23314 char *kwnames[] = {
23315 (char *) "self",(char *) "other", NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23322 if (SWIG_arg_fail(2)) SWIG_fail;
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23326
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 {
23331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23332 }
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 wxDateTime *arg2 = (wxDateTime *) 0 ;
23343 bool result;
23344 PyObject * obj0 = 0 ;
23345 PyObject * obj1 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self",(char *) "other", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(2)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxDateTime *arg1 = (wxDateTime *) 0 ;
23374 wxDateTime *arg2 = (wxDateTime *) 0 ;
23375 bool result;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char *kwnames[] = {
23379 (char *) "self",(char *) "other", NULL
23380 };
23381
23382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23384 if (SWIG_arg_fail(1)) SWIG_fail;
23385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23386 if (SWIG_arg_fail(2)) SWIG_fail;
23387 {
23388 PyThreadState* __tstate = wxPyBeginAllowThreads();
23389 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23390
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 {
23395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23396 }
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj;
23405 wxDateTime *arg1 = (wxDateTime *) 0 ;
23406 wxString *arg2 = 0 ;
23407 int result;
23408 bool temp2 = false ;
23409 PyObject * obj0 = 0 ;
23410 PyObject * obj1 = 0 ;
23411 char *kwnames[] = {
23412 (char *) "self",(char *) "date", NULL
23413 };
23414
23415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23417 if (SWIG_arg_fail(1)) SWIG_fail;
23418 {
23419 arg2 = wxString_in_helper(obj1);
23420 if (arg2 == NULL) SWIG_fail;
23421 temp2 = true;
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 {
23431 resultobj = SWIG_From_int((int)(result));
23432 }
23433 {
23434 if (temp2)
23435 delete arg2;
23436 }
23437 return resultobj;
23438 fail:
23439 {
23440 if (temp2)
23441 delete arg2;
23442 }
23443 return NULL;
23444 }
23445
23446
23447 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23448 PyObject *resultobj;
23449 wxDateTime *arg1 = (wxDateTime *) 0 ;
23450 wxString *arg2 = 0 ;
23451 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23452 wxString *arg3 = (wxString *) &arg3_defvalue ;
23453 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23454 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23455 int result;
23456 bool temp2 = false ;
23457 bool temp3 = false ;
23458 PyObject * obj0 = 0 ;
23459 PyObject * obj1 = 0 ;
23460 PyObject * obj2 = 0 ;
23461 PyObject * obj3 = 0 ;
23462 char *kwnames[] = {
23463 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23464 };
23465
23466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23468 if (SWIG_arg_fail(1)) SWIG_fail;
23469 {
23470 arg2 = wxString_in_helper(obj1);
23471 if (arg2 == NULL) SWIG_fail;
23472 temp2 = true;
23473 }
23474 if (obj2) {
23475 {
23476 arg3 = wxString_in_helper(obj2);
23477 if (arg3 == NULL) SWIG_fail;
23478 temp3 = true;
23479 }
23480 }
23481 if (obj3) {
23482 {
23483 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(4)) SWIG_fail;
23485 if (arg4 == NULL) {
23486 SWIG_null_ref("wxDateTime");
23487 }
23488 if (SWIG_arg_fail(4)) SWIG_fail;
23489 }
23490 }
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23494
23495 wxPyEndAllowThreads(__tstate);
23496 if (PyErr_Occurred()) SWIG_fail;
23497 }
23498 {
23499 resultobj = SWIG_From_int((int)(result));
23500 }
23501 {
23502 if (temp2)
23503 delete arg2;
23504 }
23505 {
23506 if (temp3)
23507 delete arg3;
23508 }
23509 return resultobj;
23510 fail:
23511 {
23512 if (temp2)
23513 delete arg2;
23514 }
23515 {
23516 if (temp3)
23517 delete arg3;
23518 }
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxDateTime *arg1 = (wxDateTime *) 0 ;
23526 wxString *arg2 = 0 ;
23527 int result;
23528 bool temp2 = false ;
23529 PyObject * obj0 = 0 ;
23530 PyObject * obj1 = 0 ;
23531 char *kwnames[] = {
23532 (char *) "self",(char *) "datetime", NULL
23533 };
23534
23535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23537 if (SWIG_arg_fail(1)) SWIG_fail;
23538 {
23539 arg2 = wxString_in_helper(obj1);
23540 if (arg2 == NULL) SWIG_fail;
23541 temp2 = true;
23542 }
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = SWIG_From_int((int)(result));
23552 }
23553 {
23554 if (temp2)
23555 delete arg2;
23556 }
23557 return resultobj;
23558 fail:
23559 {
23560 if (temp2)
23561 delete arg2;
23562 }
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 wxDateTime *arg1 = (wxDateTime *) 0 ;
23570 wxString *arg2 = 0 ;
23571 int result;
23572 bool temp2 = false ;
23573 PyObject * obj0 = 0 ;
23574 PyObject * obj1 = 0 ;
23575 char *kwnames[] = {
23576 (char *) "self",(char *) "date", NULL
23577 };
23578
23579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23581 if (SWIG_arg_fail(1)) SWIG_fail;
23582 {
23583 arg2 = wxString_in_helper(obj1);
23584 if (arg2 == NULL) SWIG_fail;
23585 temp2 = true;
23586 }
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 {
23595 resultobj = SWIG_From_int((int)(result));
23596 }
23597 {
23598 if (temp2)
23599 delete arg2;
23600 }
23601 return resultobj;
23602 fail:
23603 {
23604 if (temp2)
23605 delete arg2;
23606 }
23607 return NULL;
23608 }
23609
23610
23611 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23612 PyObject *resultobj;
23613 wxDateTime *arg1 = (wxDateTime *) 0 ;
23614 wxString *arg2 = 0 ;
23615 int result;
23616 bool temp2 = false ;
23617 PyObject * obj0 = 0 ;
23618 PyObject * obj1 = 0 ;
23619 char *kwnames[] = {
23620 (char *) "self",(char *) "time", NULL
23621 };
23622
23623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23625 if (SWIG_arg_fail(1)) SWIG_fail;
23626 {
23627 arg2 = wxString_in_helper(obj1);
23628 if (arg2 == NULL) SWIG_fail;
23629 temp2 = true;
23630 }
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23634
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = SWIG_From_int((int)(result));
23640 }
23641 {
23642 if (temp2)
23643 delete arg2;
23644 }
23645 return resultobj;
23646 fail:
23647 {
23648 if (temp2)
23649 delete arg2;
23650 }
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 wxDateTime *arg1 = (wxDateTime *) 0 ;
23658 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23659 wxString *arg2 = (wxString *) &arg2_defvalue ;
23660 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23661 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23662 wxString result;
23663 bool temp2 = false ;
23664 bool temp3 = false ;
23665 PyObject * obj0 = 0 ;
23666 PyObject * obj1 = 0 ;
23667 PyObject * obj2 = 0 ;
23668 char *kwnames[] = {
23669 (char *) "self",(char *) "format",(char *) "tz", NULL
23670 };
23671
23672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23674 if (SWIG_arg_fail(1)) SWIG_fail;
23675 if (obj1) {
23676 {
23677 arg2 = wxString_in_helper(obj1);
23678 if (arg2 == NULL) SWIG_fail;
23679 temp2 = true;
23680 }
23681 }
23682 if (obj2) {
23683 {
23684 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23685 temp3 = true;
23686 }
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23691
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 {
23696 #if wxUSE_UNICODE
23697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23698 #else
23699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23700 #endif
23701 }
23702 {
23703 if (temp2)
23704 delete arg2;
23705 }
23706 {
23707 if (temp3) delete arg3;
23708 }
23709 return resultobj;
23710 fail:
23711 {
23712 if (temp2)
23713 delete arg2;
23714 }
23715 {
23716 if (temp3) delete arg3;
23717 }
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxDateTime *arg1 = (wxDateTime *) 0 ;
23725 wxString result;
23726 PyObject * obj0 = 0 ;
23727 char *kwnames[] = {
23728 (char *) "self", NULL
23729 };
23730
23731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23733 if (SWIG_arg_fail(1)) SWIG_fail;
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = ((wxDateTime const *)arg1)->FormatDate();
23737
23738 wxPyEndAllowThreads(__tstate);
23739 if (PyErr_Occurred()) SWIG_fail;
23740 }
23741 {
23742 #if wxUSE_UNICODE
23743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23744 #else
23745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23746 #endif
23747 }
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj;
23756 wxDateTime *arg1 = (wxDateTime *) 0 ;
23757 wxString result;
23758 PyObject * obj0 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = ((wxDateTime const *)arg1)->FormatTime();
23769
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 {
23774 #if wxUSE_UNICODE
23775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23776 #else
23777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23778 #endif
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 wxDateTime *arg1 = (wxDateTime *) 0 ;
23789 wxString result;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "self", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23797 if (SWIG_arg_fail(1)) SWIG_fail;
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = ((wxDateTime const *)arg1)->FormatISODate();
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 #if wxUSE_UNICODE
23807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23808 #else
23809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23810 #endif
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj;
23820 wxDateTime *arg1 = (wxDateTime *) 0 ;
23821 wxString result;
23822 PyObject * obj0 = 0 ;
23823 char *kwnames[] = {
23824 (char *) "self", NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = ((wxDateTime const *)arg1)->FormatISOTime();
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 #if wxUSE_UNICODE
23839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23840 #else
23841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23842 #endif
23843 }
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23851 PyObject *obj;
23852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23853 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23854 Py_INCREF(obj);
23855 return Py_BuildValue((char *)"");
23856 }
23857 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj;
23859 long arg1 ;
23860 wxTimeSpan result;
23861 PyObject * obj0 = 0 ;
23862 char *kwnames[] = {
23863 (char *) "sec", NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23867 {
23868 arg1 = (long)(SWIG_As_long(obj0));
23869 if (SWIG_arg_fail(1)) SWIG_fail;
23870 }
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = wxTimeSpan::Seconds(arg1);
23874
23875 wxPyEndAllowThreads(__tstate);
23876 if (PyErr_Occurred()) SWIG_fail;
23877 }
23878 {
23879 wxTimeSpan * resultptr;
23880 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23882 }
23883 return resultobj;
23884 fail:
23885 return NULL;
23886 }
23887
23888
23889 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23890 PyObject *resultobj;
23891 wxTimeSpan result;
23892 char *kwnames[] = {
23893 NULL
23894 };
23895
23896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = wxTimeSpan::Second();
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 wxTimeSpan * resultptr;
23906 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 long arg1 ;
23918 wxTimeSpan result;
23919 PyObject * obj0 = 0 ;
23920 char *kwnames[] = {
23921 (char *) "min", NULL
23922 };
23923
23924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23925 {
23926 arg1 = (long)(SWIG_As_long(obj0));
23927 if (SWIG_arg_fail(1)) SWIG_fail;
23928 }
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = wxTimeSpan::Minutes(arg1);
23932
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 wxTimeSpan * resultptr;
23938 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23940 }
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23948 PyObject *resultobj;
23949 wxTimeSpan result;
23950 char *kwnames[] = {
23951 NULL
23952 };
23953
23954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = wxTimeSpan::Minute();
23958
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 {
23963 wxTimeSpan * resultptr;
23964 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23966 }
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 long arg1 ;
23976 wxTimeSpan result;
23977 PyObject * obj0 = 0 ;
23978 char *kwnames[] = {
23979 (char *) "hours", NULL
23980 };
23981
23982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23983 {
23984 arg1 = (long)(SWIG_As_long(obj0));
23985 if (SWIG_arg_fail(1)) SWIG_fail;
23986 }
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = wxTimeSpan::Hours(arg1);
23990
23991 wxPyEndAllowThreads(__tstate);
23992 if (PyErr_Occurred()) SWIG_fail;
23993 }
23994 {
23995 wxTimeSpan * resultptr;
23996 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24006 PyObject *resultobj;
24007 wxTimeSpan result;
24008 char *kwnames[] = {
24009 NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24013 {
24014 PyThreadState* __tstate = wxPyBeginAllowThreads();
24015 result = wxTimeSpan::Hour();
24016
24017 wxPyEndAllowThreads(__tstate);
24018 if (PyErr_Occurred()) SWIG_fail;
24019 }
24020 {
24021 wxTimeSpan * resultptr;
24022 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24024 }
24025 return resultobj;
24026 fail:
24027 return NULL;
24028 }
24029
24030
24031 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24032 PyObject *resultobj;
24033 long arg1 ;
24034 wxTimeSpan result;
24035 PyObject * obj0 = 0 ;
24036 char *kwnames[] = {
24037 (char *) "days", NULL
24038 };
24039
24040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24041 {
24042 arg1 = (long)(SWIG_As_long(obj0));
24043 if (SWIG_arg_fail(1)) SWIG_fail;
24044 }
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = wxTimeSpan::Days(arg1);
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 {
24053 wxTimeSpan * resultptr;
24054 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24056 }
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj;
24065 wxTimeSpan result;
24066 char *kwnames[] = {
24067 NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = wxTimeSpan::Day();
24074
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 {
24079 wxTimeSpan * resultptr;
24080 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24082 }
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 long arg1 ;
24092 wxTimeSpan result;
24093 PyObject * obj0 = 0 ;
24094 char *kwnames[] = {
24095 (char *) "days", NULL
24096 };
24097
24098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24099 {
24100 arg1 = (long)(SWIG_As_long(obj0));
24101 if (SWIG_arg_fail(1)) SWIG_fail;
24102 }
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 result = wxTimeSpan::Weeks(arg1);
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 wxTimeSpan * resultptr;
24112 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24122 PyObject *resultobj;
24123 wxTimeSpan result;
24124 char *kwnames[] = {
24125 NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 result = wxTimeSpan::Week();
24132
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 {
24137 wxTimeSpan * resultptr;
24138 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24140 }
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 long arg1 = (long) 0 ;
24150 long arg2 = (long) 0 ;
24151 long arg3 = (long) 0 ;
24152 long arg4 = (long) 0 ;
24153 wxTimeSpan *result;
24154 PyObject * obj0 = 0 ;
24155 PyObject * obj1 = 0 ;
24156 PyObject * obj2 = 0 ;
24157 PyObject * obj3 = 0 ;
24158 char *kwnames[] = {
24159 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24160 };
24161
24162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24163 if (obj0) {
24164 {
24165 arg1 = (long)(SWIG_As_long(obj0));
24166 if (SWIG_arg_fail(1)) SWIG_fail;
24167 }
24168 }
24169 if (obj1) {
24170 {
24171 arg2 = (long)(SWIG_As_long(obj1));
24172 if (SWIG_arg_fail(2)) SWIG_fail;
24173 }
24174 }
24175 if (obj2) {
24176 {
24177 arg3 = (long)(SWIG_As_long(obj2));
24178 if (SWIG_arg_fail(3)) SWIG_fail;
24179 }
24180 }
24181 if (obj3) {
24182 {
24183 arg4 = (long)(SWIG_As_long(obj3));
24184 if (SWIG_arg_fail(4)) SWIG_fail;
24185 }
24186 }
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24190
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24202 PyObject *resultobj;
24203 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24204 PyObject * obj0 = 0 ;
24205 char *kwnames[] = {
24206 (char *) "self", NULL
24207 };
24208
24209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24211 if (SWIG_arg_fail(1)) SWIG_fail;
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 delete arg1;
24215
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 Py_INCREF(Py_None); resultobj = Py_None;
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj;
24228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24229 wxTimeSpan *arg2 = 0 ;
24230 wxTimeSpan *result;
24231 PyObject * obj0 = 0 ;
24232 PyObject * obj1 = 0 ;
24233 char *kwnames[] = {
24234 (char *) "self",(char *) "diff", NULL
24235 };
24236
24237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24239 if (SWIG_arg_fail(1)) SWIG_fail;
24240 {
24241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(2)) SWIG_fail;
24243 if (arg2 == NULL) {
24244 SWIG_null_ref("wxTimeSpan");
24245 }
24246 if (SWIG_arg_fail(2)) SWIG_fail;
24247 }
24248 {
24249 PyThreadState* __tstate = wxPyBeginAllowThreads();
24250 {
24251 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24252 result = (wxTimeSpan *) &_result_ref;
24253 }
24254
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24266 PyObject *resultobj;
24267 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24268 wxTimeSpan *arg2 = 0 ;
24269 wxTimeSpan *result;
24270 PyObject * obj0 = 0 ;
24271 PyObject * obj1 = 0 ;
24272 char *kwnames[] = {
24273 (char *) "self",(char *) "diff", NULL
24274 };
24275
24276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24278 if (SWIG_arg_fail(1)) SWIG_fail;
24279 {
24280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24281 if (SWIG_arg_fail(2)) SWIG_fail;
24282 if (arg2 == NULL) {
24283 SWIG_null_ref("wxTimeSpan");
24284 }
24285 if (SWIG_arg_fail(2)) SWIG_fail;
24286 }
24287 {
24288 PyThreadState* __tstate = wxPyBeginAllowThreads();
24289 {
24290 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24291 result = (wxTimeSpan *) &_result_ref;
24292 }
24293
24294 wxPyEndAllowThreads(__tstate);
24295 if (PyErr_Occurred()) SWIG_fail;
24296 }
24297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24298 return resultobj;
24299 fail:
24300 return NULL;
24301 }
24302
24303
24304 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24305 PyObject *resultobj;
24306 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24307 int arg2 ;
24308 wxTimeSpan *result;
24309 PyObject * obj0 = 0 ;
24310 PyObject * obj1 = 0 ;
24311 char *kwnames[] = {
24312 (char *) "self",(char *) "n", NULL
24313 };
24314
24315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24317 if (SWIG_arg_fail(1)) SWIG_fail;
24318 {
24319 arg2 = (int)(SWIG_As_int(obj1));
24320 if (SWIG_arg_fail(2)) SWIG_fail;
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 {
24325 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24326 result = (wxTimeSpan *) &_result_ref;
24327 }
24328
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24342 wxTimeSpan *result;
24343 PyObject * obj0 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 {
24354 wxTimeSpan &_result_ref = (arg1)->Neg();
24355 result = (wxTimeSpan *) &_result_ref;
24356 }
24357
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24362 return resultobj;
24363 fail:
24364 return NULL;
24365 }
24366
24367
24368 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24369 PyObject *resultobj;
24370 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24371 wxTimeSpan result;
24372 PyObject * obj0 = 0 ;
24373 char *kwnames[] = {
24374 (char *) "self", NULL
24375 };
24376
24377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24379 if (SWIG_arg_fail(1)) SWIG_fail;
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 result = ((wxTimeSpan const *)arg1)->Abs();
24383
24384 wxPyEndAllowThreads(__tstate);
24385 if (PyErr_Occurred()) SWIG_fail;
24386 }
24387 {
24388 wxTimeSpan * resultptr;
24389 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24391 }
24392 return resultobj;
24393 fail:
24394 return NULL;
24395 }
24396
24397
24398 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj;
24400 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24401 wxTimeSpan *arg2 = 0 ;
24402 wxTimeSpan *result;
24403 PyObject * obj0 = 0 ;
24404 PyObject * obj1 = 0 ;
24405 char *kwnames[] = {
24406 (char *) "self",(char *) "diff", NULL
24407 };
24408
24409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24411 if (SWIG_arg_fail(1)) SWIG_fail;
24412 {
24413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24414 if (SWIG_arg_fail(2)) SWIG_fail;
24415 if (arg2 == NULL) {
24416 SWIG_null_ref("wxTimeSpan");
24417 }
24418 if (SWIG_arg_fail(2)) SWIG_fail;
24419 }
24420 {
24421 PyThreadState* __tstate = wxPyBeginAllowThreads();
24422 {
24423 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24424 result = (wxTimeSpan *) &_result_ref;
24425 }
24426
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24431 return resultobj;
24432 fail:
24433 return NULL;
24434 }
24435
24436
24437 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24438 PyObject *resultobj;
24439 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24440 wxTimeSpan *arg2 = 0 ;
24441 wxTimeSpan *result;
24442 PyObject * obj0 = 0 ;
24443 PyObject * obj1 = 0 ;
24444 char *kwnames[] = {
24445 (char *) "self",(char *) "diff", NULL
24446 };
24447
24448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24450 if (SWIG_arg_fail(1)) SWIG_fail;
24451 {
24452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24453 if (SWIG_arg_fail(2)) SWIG_fail;
24454 if (arg2 == NULL) {
24455 SWIG_null_ref("wxTimeSpan");
24456 }
24457 if (SWIG_arg_fail(2)) SWIG_fail;
24458 }
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 {
24462 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24463 result = (wxTimeSpan *) &_result_ref;
24464 }
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24479 int arg2 ;
24480 wxTimeSpan *result;
24481 PyObject * obj0 = 0 ;
24482 PyObject * obj1 = 0 ;
24483 char *kwnames[] = {
24484 (char *) "self",(char *) "n", NULL
24485 };
24486
24487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24489 if (SWIG_arg_fail(1)) SWIG_fail;
24490 {
24491 arg2 = (int)(SWIG_As_int(obj1));
24492 if (SWIG_arg_fail(2)) SWIG_fail;
24493 }
24494 {
24495 PyThreadState* __tstate = wxPyBeginAllowThreads();
24496 {
24497 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24498 result = (wxTimeSpan *) &_result_ref;
24499 }
24500
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj;
24513 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24514 wxTimeSpan *result;
24515 PyObject * obj0 = 0 ;
24516 char *kwnames[] = {
24517 (char *) "self", NULL
24518 };
24519
24520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 {
24526 wxTimeSpan &_result_ref = (arg1)->operator -();
24527 result = (wxTimeSpan *) &_result_ref;
24528 }
24529
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24534 return resultobj;
24535 fail:
24536 return NULL;
24537 }
24538
24539
24540 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj;
24542 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24543 wxTimeSpan *arg2 = 0 ;
24544 wxTimeSpan result;
24545 PyObject * obj0 = 0 ;
24546 PyObject * obj1 = 0 ;
24547 char *kwnames[] = {
24548 (char *) "self",(char *) "other", NULL
24549 };
24550
24551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24553 if (SWIG_arg_fail(1)) SWIG_fail;
24554 {
24555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24556 if (SWIG_arg_fail(2)) SWIG_fail;
24557 if (arg2 == NULL) {
24558 SWIG_null_ref("wxTimeSpan");
24559 }
24560 if (SWIG_arg_fail(2)) SWIG_fail;
24561 }
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 wxTimeSpan * resultptr;
24571 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24573 }
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj;
24582 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24583 wxTimeSpan *arg2 = 0 ;
24584 wxTimeSpan result;
24585 PyObject * obj0 = 0 ;
24586 PyObject * obj1 = 0 ;
24587 char *kwnames[] = {
24588 (char *) "self",(char *) "other", NULL
24589 };
24590
24591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24593 if (SWIG_arg_fail(1)) SWIG_fail;
24594 {
24595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(2)) SWIG_fail;
24597 if (arg2 == NULL) {
24598 SWIG_null_ref("wxTimeSpan");
24599 }
24600 if (SWIG_arg_fail(2)) SWIG_fail;
24601 }
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24605
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 {
24610 wxTimeSpan * resultptr;
24611 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24613 }
24614 return resultobj;
24615 fail:
24616 return NULL;
24617 }
24618
24619
24620 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24621 PyObject *resultobj;
24622 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24623 int arg2 ;
24624 wxTimeSpan result;
24625 PyObject * obj0 = 0 ;
24626 PyObject * obj1 = 0 ;
24627 char *kwnames[] = {
24628 (char *) "self",(char *) "n", NULL
24629 };
24630
24631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(1)) SWIG_fail;
24634 {
24635 arg2 = (int)(SWIG_As_int(obj1));
24636 if (SWIG_arg_fail(2)) SWIG_fail;
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = wxTimeSpan___mul__(arg1,arg2);
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 {
24646 wxTimeSpan * resultptr;
24647 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24649 }
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj;
24658 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24659 int arg2 ;
24660 wxTimeSpan result;
24661 PyObject * obj0 = 0 ;
24662 PyObject * obj1 = 0 ;
24663 char *kwnames[] = {
24664 (char *) "self",(char *) "n", NULL
24665 };
24666
24667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24669 if (SWIG_arg_fail(1)) SWIG_fail;
24670 {
24671 arg2 = (int)(SWIG_As_int(obj1));
24672 if (SWIG_arg_fail(2)) SWIG_fail;
24673 }
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = wxTimeSpan___rmul__(arg1,arg2);
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 wxTimeSpan * resultptr;
24683 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24685 }
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj;
24694 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24695 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24696 bool result;
24697 PyObject * obj0 = 0 ;
24698 PyObject * obj1 = 0 ;
24699 char *kwnames[] = {
24700 (char *) "self",(char *) "other", NULL
24701 };
24702
24703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24705 if (SWIG_arg_fail(1)) SWIG_fail;
24706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24707 if (SWIG_arg_fail(2)) SWIG_fail;
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24711
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj;
24726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24727 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24728 bool result;
24729 PyObject * obj0 = 0 ;
24730 PyObject * obj1 = 0 ;
24731 char *kwnames[] = {
24732 (char *) "self",(char *) "other", NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(1)) SWIG_fail;
24738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24739 if (SWIG_arg_fail(2)) SWIG_fail;
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24743
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24757 PyObject *resultobj;
24758 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24759 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24760 bool result;
24761 PyObject * obj0 = 0 ;
24762 PyObject * obj1 = 0 ;
24763 char *kwnames[] = {
24764 (char *) "self",(char *) "other", NULL
24765 };
24766
24767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24769 if (SWIG_arg_fail(1)) SWIG_fail;
24770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24771 if (SWIG_arg_fail(2)) SWIG_fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24791 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24792 bool result;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self",(char *) "other", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24803 if (SWIG_arg_fail(2)) SWIG_fail;
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24807
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24821 PyObject *resultobj;
24822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24823 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24824 bool result;
24825 PyObject * obj0 = 0 ;
24826 PyObject * obj1 = 0 ;
24827 char *kwnames[] = {
24828 (char *) "self",(char *) "other", NULL
24829 };
24830
24831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(1)) SWIG_fail;
24834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24835 if (SWIG_arg_fail(2)) SWIG_fail;
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 {
24844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24845 }
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj;
24854 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24855 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24856 bool result;
24857 PyObject * obj0 = 0 ;
24858 PyObject * obj1 = 0 ;
24859 char *kwnames[] = {
24860 (char *) "self",(char *) "other", NULL
24861 };
24862
24863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24865 if (SWIG_arg_fail(1)) SWIG_fail;
24866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24867 if (SWIG_arg_fail(2)) SWIG_fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24877 }
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj;
24886 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24887 bool result;
24888 PyObject * obj0 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "self", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24895 if (SWIG_arg_fail(1)) SWIG_fail;
24896 {
24897 PyThreadState* __tstate = wxPyBeginAllowThreads();
24898 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24899
24900 wxPyEndAllowThreads(__tstate);
24901 if (PyErr_Occurred()) SWIG_fail;
24902 }
24903 {
24904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24905 }
24906 return resultobj;
24907 fail:
24908 return NULL;
24909 }
24910
24911
24912 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24913 PyObject *resultobj;
24914 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24915 bool result;
24916 PyObject * obj0 = 0 ;
24917 char *kwnames[] = {
24918 (char *) "self", NULL
24919 };
24920
24921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24923 if (SWIG_arg_fail(1)) SWIG_fail;
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24927
24928 wxPyEndAllowThreads(__tstate);
24929 if (PyErr_Occurred()) SWIG_fail;
24930 }
24931 {
24932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24933 }
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24941 PyObject *resultobj;
24942 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24943 bool result;
24944 PyObject * obj0 = 0 ;
24945 char *kwnames[] = {
24946 (char *) "self", NULL
24947 };
24948
24949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(1)) SWIG_fail;
24952 {
24953 PyThreadState* __tstate = wxPyBeginAllowThreads();
24954 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24955
24956 wxPyEndAllowThreads(__tstate);
24957 if (PyErr_Occurred()) SWIG_fail;
24958 }
24959 {
24960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24961 }
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj;
24970 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24971 wxTimeSpan *arg2 = 0 ;
24972 bool result;
24973 PyObject * obj0 = 0 ;
24974 PyObject * obj1 = 0 ;
24975 char *kwnames[] = {
24976 (char *) "self",(char *) "ts", NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(1)) SWIG_fail;
24982 {
24983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(2)) SWIG_fail;
24985 if (arg2 == NULL) {
24986 SWIG_null_ref("wxTimeSpan");
24987 }
24988 if (SWIG_arg_fail(2)) SWIG_fail;
24989 }
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24993
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 {
24998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24999 }
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj;
25008 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25009 wxTimeSpan *arg2 = 0 ;
25010 bool result;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 char *kwnames[] = {
25014 (char *) "self",(char *) "ts", NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25019 if (SWIG_arg_fail(1)) SWIG_fail;
25020 {
25021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 if (arg2 == NULL) {
25024 SWIG_null_ref("wxTimeSpan");
25025 }
25026 if (SWIG_arg_fail(2)) SWIG_fail;
25027 }
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25031
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj;
25046 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25047 wxTimeSpan *arg2 = 0 ;
25048 bool result;
25049 PyObject * obj0 = 0 ;
25050 PyObject * obj1 = 0 ;
25051 char *kwnames[] = {
25052 (char *) "self",(char *) "t", NULL
25053 };
25054
25055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25057 if (SWIG_arg_fail(1)) SWIG_fail;
25058 {
25059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(2)) SWIG_fail;
25061 if (arg2 == NULL) {
25062 SWIG_null_ref("wxTimeSpan");
25063 }
25064 if (SWIG_arg_fail(2)) SWIG_fail;
25065 }
25066 {
25067 PyThreadState* __tstate = wxPyBeginAllowThreads();
25068 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25069
25070 wxPyEndAllowThreads(__tstate);
25071 if (PyErr_Occurred()) SWIG_fail;
25072 }
25073 {
25074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25075 }
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj;
25084 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25085 int result;
25086 PyObject * obj0 = 0 ;
25087 char *kwnames[] = {
25088 (char *) "self", NULL
25089 };
25090
25091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25093 if (SWIG_arg_fail(1)) SWIG_fail;
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25097
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 {
25102 resultobj = SWIG_From_int((int)(result));
25103 }
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj;
25112 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25113 int result;
25114 PyObject * obj0 = 0 ;
25115 char *kwnames[] = {
25116 (char *) "self", NULL
25117 };
25118
25119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25121 if (SWIG_arg_fail(1)) SWIG_fail;
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25125
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = SWIG_From_int((int)(result));
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj;
25140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25141 int result;
25142 PyObject * obj0 = 0 ;
25143 char *kwnames[] = {
25144 (char *) "self", NULL
25145 };
25146
25147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25149 if (SWIG_arg_fail(1)) SWIG_fail;
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25153
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = SWIG_From_int((int)(result));
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25167 PyObject *resultobj;
25168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25169 int result;
25170 PyObject * obj0 = 0 ;
25171 char *kwnames[] = {
25172 (char *) "self", NULL
25173 };
25174
25175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25177 if (SWIG_arg_fail(1)) SWIG_fail;
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25181
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 {
25186 resultobj = SWIG_From_int((int)(result));
25187 }
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25195 PyObject *resultobj;
25196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25197 wxLongLong result;
25198 PyObject * obj0 = 0 ;
25199 char *kwnames[] = {
25200 (char *) "self", NULL
25201 };
25202
25203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25205 if (SWIG_arg_fail(1)) SWIG_fail;
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25209
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 {
25214 PyObject *hi, *lo, *shifter, *shifted;
25215 hi = PyLong_FromLong( (&result)->GetHi() );
25216 lo = PyLong_FromLong( (&result)->GetLo() );
25217 shifter = PyLong_FromLong(32);
25218 shifted = PyNumber_Lshift(hi, shifter);
25219 resultobj = PyNumber_Or(shifted, lo);
25220 Py_DECREF(hi);
25221 Py_DECREF(lo);
25222 Py_DECREF(shifter);
25223 Py_DECREF(shifted);
25224 }
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25232 PyObject *resultobj;
25233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25234 wxLongLong result;
25235 PyObject * obj0 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25242 if (SWIG_arg_fail(1)) SWIG_fail;
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25246
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 {
25251 PyObject *hi, *lo, *shifter, *shifted;
25252 hi = PyLong_FromLong( (&result)->GetHi() );
25253 lo = PyLong_FromLong( (&result)->GetLo() );
25254 shifter = PyLong_FromLong(32);
25255 shifted = PyNumber_Lshift(hi, shifter);
25256 resultobj = PyNumber_Or(shifted, lo);
25257 Py_DECREF(hi);
25258 Py_DECREF(lo);
25259 Py_DECREF(shifter);
25260 Py_DECREF(shifted);
25261 }
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj;
25270 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25271 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25272 wxString *arg2 = (wxString *) &arg2_defvalue ;
25273 wxString result;
25274 bool temp2 = false ;
25275 PyObject * obj0 = 0 ;
25276 PyObject * obj1 = 0 ;
25277 char *kwnames[] = {
25278 (char *) "self",(char *) "format", NULL
25279 };
25280
25281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25283 if (SWIG_arg_fail(1)) SWIG_fail;
25284 if (obj1) {
25285 {
25286 arg2 = wxString_in_helper(obj1);
25287 if (arg2 == NULL) SWIG_fail;
25288 temp2 = true;
25289 }
25290 }
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25294
25295 wxPyEndAllowThreads(__tstate);
25296 if (PyErr_Occurred()) SWIG_fail;
25297 }
25298 {
25299 #if wxUSE_UNICODE
25300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25301 #else
25302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25303 #endif
25304 }
25305 {
25306 if (temp2)
25307 delete arg2;
25308 }
25309 return resultobj;
25310 fail:
25311 {
25312 if (temp2)
25313 delete arg2;
25314 }
25315 return NULL;
25316 }
25317
25318
25319 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25320 PyObject *obj;
25321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25322 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25323 Py_INCREF(obj);
25324 return Py_BuildValue((char *)"");
25325 }
25326 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj;
25328 int arg1 = (int) 0 ;
25329 int arg2 = (int) 0 ;
25330 int arg3 = (int) 0 ;
25331 int arg4 = (int) 0 ;
25332 wxDateSpan *result;
25333 PyObject * obj0 = 0 ;
25334 PyObject * obj1 = 0 ;
25335 PyObject * obj2 = 0 ;
25336 PyObject * obj3 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25342 if (obj0) {
25343 {
25344 arg1 = (int)(SWIG_As_int(obj0));
25345 if (SWIG_arg_fail(1)) SWIG_fail;
25346 }
25347 }
25348 if (obj1) {
25349 {
25350 arg2 = (int)(SWIG_As_int(obj1));
25351 if (SWIG_arg_fail(2)) SWIG_fail;
25352 }
25353 }
25354 if (obj2) {
25355 {
25356 arg3 = (int)(SWIG_As_int(obj2));
25357 if (SWIG_arg_fail(3)) SWIG_fail;
25358 }
25359 }
25360 if (obj3) {
25361 {
25362 arg4 = (int)(SWIG_As_int(obj3));
25363 if (SWIG_arg_fail(4)) SWIG_fail;
25364 }
25365 }
25366 {
25367 PyThreadState* __tstate = wxPyBeginAllowThreads();
25368 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25369
25370 wxPyEndAllowThreads(__tstate);
25371 if (PyErr_Occurred()) SWIG_fail;
25372 }
25373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj;
25382 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25383 PyObject * obj0 = 0 ;
25384 char *kwnames[] = {
25385 (char *) "self", NULL
25386 };
25387
25388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25390 if (SWIG_arg_fail(1)) SWIG_fail;
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 delete arg1;
25394
25395 wxPyEndAllowThreads(__tstate);
25396 if (PyErr_Occurred()) SWIG_fail;
25397 }
25398 Py_INCREF(Py_None); resultobj = Py_None;
25399 return resultobj;
25400 fail:
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 int arg1 ;
25408 wxDateSpan result;
25409 PyObject * obj0 = 0 ;
25410 char *kwnames[] = {
25411 (char *) "days", NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25415 {
25416 arg1 = (int)(SWIG_As_int(obj0));
25417 if (SWIG_arg_fail(1)) SWIG_fail;
25418 }
25419 {
25420 PyThreadState* __tstate = wxPyBeginAllowThreads();
25421 result = wxDateSpan::Days(arg1);
25422
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 {
25427 wxDateSpan * resultptr;
25428 resultptr = new wxDateSpan((wxDateSpan &)(result));
25429 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj;
25439 wxDateSpan result;
25440 char *kwnames[] = {
25441 NULL
25442 };
25443
25444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25445 {
25446 PyThreadState* __tstate = wxPyBeginAllowThreads();
25447 result = wxDateSpan::Day();
25448
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 {
25453 wxDateSpan * resultptr;
25454 resultptr = new wxDateSpan((wxDateSpan &)(result));
25455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25456 }
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj;
25465 int arg1 ;
25466 wxDateSpan result;
25467 PyObject * obj0 = 0 ;
25468 char *kwnames[] = {
25469 (char *) "weeks", NULL
25470 };
25471
25472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25473 {
25474 arg1 = (int)(SWIG_As_int(obj0));
25475 if (SWIG_arg_fail(1)) SWIG_fail;
25476 }
25477 {
25478 PyThreadState* __tstate = wxPyBeginAllowThreads();
25479 result = wxDateSpan::Weeks(arg1);
25480
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 {
25485 wxDateSpan * resultptr;
25486 resultptr = new wxDateSpan((wxDateSpan &)(result));
25487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25488 }
25489 return resultobj;
25490 fail:
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 wxDateSpan result;
25498 char *kwnames[] = {
25499 NULL
25500 };
25501
25502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = wxDateSpan::Week();
25506
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 {
25511 wxDateSpan * resultptr;
25512 resultptr = new wxDateSpan((wxDateSpan &)(result));
25513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25514 }
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 int arg1 ;
25524 wxDateSpan result;
25525 PyObject * obj0 = 0 ;
25526 char *kwnames[] = {
25527 (char *) "mon", NULL
25528 };
25529
25530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25531 {
25532 arg1 = (int)(SWIG_As_int(obj0));
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 }
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = wxDateSpan::Months(arg1);
25538
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 {
25543 wxDateSpan * resultptr;
25544 resultptr = new wxDateSpan((wxDateSpan &)(result));
25545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25546 }
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25554 PyObject *resultobj;
25555 wxDateSpan result;
25556 char *kwnames[] = {
25557 NULL
25558 };
25559
25560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = wxDateSpan::Month();
25564
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 {
25569 wxDateSpan * resultptr;
25570 resultptr = new wxDateSpan((wxDateSpan &)(result));
25571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25572 }
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj;
25581 int arg1 ;
25582 wxDateSpan result;
25583 PyObject * obj0 = 0 ;
25584 char *kwnames[] = {
25585 (char *) "years", NULL
25586 };
25587
25588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25589 {
25590 arg1 = (int)(SWIG_As_int(obj0));
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 }
25593 {
25594 PyThreadState* __tstate = wxPyBeginAllowThreads();
25595 result = wxDateSpan::Years(arg1);
25596
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 wxDateSpan * resultptr;
25602 resultptr = new wxDateSpan((wxDateSpan &)(result));
25603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25604 }
25605 return resultobj;
25606 fail:
25607 return NULL;
25608 }
25609
25610
25611 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25612 PyObject *resultobj;
25613 wxDateSpan result;
25614 char *kwnames[] = {
25615 NULL
25616 };
25617
25618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 result = wxDateSpan::Year();
25622
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 {
25627 wxDateSpan * resultptr;
25628 resultptr = new wxDateSpan((wxDateSpan &)(result));
25629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25630 }
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25638 PyObject *resultobj;
25639 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25640 int arg2 ;
25641 wxDateSpan *result;
25642 PyObject * obj0 = 0 ;
25643 PyObject * obj1 = 0 ;
25644 char *kwnames[] = {
25645 (char *) "self",(char *) "n", NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25650 if (SWIG_arg_fail(1)) SWIG_fail;
25651 {
25652 arg2 = (int)(SWIG_As_int(obj1));
25653 if (SWIG_arg_fail(2)) SWIG_fail;
25654 }
25655 {
25656 PyThreadState* __tstate = wxPyBeginAllowThreads();
25657 {
25658 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25659 result = (wxDateSpan *) &_result_ref;
25660 }
25661
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25675 int arg2 ;
25676 wxDateSpan *result;
25677 PyObject * obj0 = 0 ;
25678 PyObject * obj1 = 0 ;
25679 char *kwnames[] = {
25680 (char *) "self",(char *) "n", NULL
25681 };
25682
25683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 {
25687 arg2 = (int)(SWIG_As_int(obj1));
25688 if (SWIG_arg_fail(2)) SWIG_fail;
25689 }
25690 {
25691 PyThreadState* __tstate = wxPyBeginAllowThreads();
25692 {
25693 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25694 result = (wxDateSpan *) &_result_ref;
25695 }
25696
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25708 PyObject *resultobj;
25709 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25710 int arg2 ;
25711 wxDateSpan *result;
25712 PyObject * obj0 = 0 ;
25713 PyObject * obj1 = 0 ;
25714 char *kwnames[] = {
25715 (char *) "self",(char *) "n", NULL
25716 };
25717
25718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25720 if (SWIG_arg_fail(1)) SWIG_fail;
25721 {
25722 arg2 = (int)(SWIG_As_int(obj1));
25723 if (SWIG_arg_fail(2)) SWIG_fail;
25724 }
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 {
25728 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25729 result = (wxDateSpan *) &_result_ref;
25730 }
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25736 return resultobj;
25737 fail:
25738 return NULL;
25739 }
25740
25741
25742 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25743 PyObject *resultobj;
25744 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25745 int arg2 ;
25746 wxDateSpan *result;
25747 PyObject * obj0 = 0 ;
25748 PyObject * obj1 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self",(char *) "n", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 arg2 = (int)(SWIG_As_int(obj1));
25758 if (SWIG_arg_fail(2)) SWIG_fail;
25759 }
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 {
25763 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25764 result = (wxDateSpan *) &_result_ref;
25765 }
25766
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj;
25779 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25780 int result;
25781 PyObject * obj0 = 0 ;
25782 char *kwnames[] = {
25783 (char *) "self", NULL
25784 };
25785
25786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25788 if (SWIG_arg_fail(1)) SWIG_fail;
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = (int)((wxDateSpan const *)arg1)->GetYears();
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 {
25797 resultobj = SWIG_From_int((int)(result));
25798 }
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj;
25807 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25808 int result;
25809 PyObject * obj0 = 0 ;
25810 char *kwnames[] = {
25811 (char *) "self", NULL
25812 };
25813
25814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25816 if (SWIG_arg_fail(1)) SWIG_fail;
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25820
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 {
25825 resultobj = SWIG_From_int((int)(result));
25826 }
25827 return resultobj;
25828 fail:
25829 return NULL;
25830 }
25831
25832
25833 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25834 PyObject *resultobj;
25835 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25836 int result;
25837 PyObject * obj0 = 0 ;
25838 char *kwnames[] = {
25839 (char *) "self", NULL
25840 };
25841
25842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25844 if (SWIG_arg_fail(1)) SWIG_fail;
25845 {
25846 PyThreadState* __tstate = wxPyBeginAllowThreads();
25847 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25848
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 {
25853 resultobj = SWIG_From_int((int)(result));
25854 }
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj;
25863 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25864 int result;
25865 PyObject * obj0 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25872 if (SWIG_arg_fail(1)) SWIG_fail;
25873 {
25874 PyThreadState* __tstate = wxPyBeginAllowThreads();
25875 result = (int)((wxDateSpan const *)arg1)->GetDays();
25876
25877 wxPyEndAllowThreads(__tstate);
25878 if (PyErr_Occurred()) SWIG_fail;
25879 }
25880 {
25881 resultobj = SWIG_From_int((int)(result));
25882 }
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj;
25891 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25892 int result;
25893 PyObject * obj0 = 0 ;
25894 char *kwnames[] = {
25895 (char *) "self", NULL
25896 };
25897
25898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(1)) SWIG_fail;
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25904
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 {
25909 resultobj = SWIG_From_int((int)(result));
25910 }
25911 return resultobj;
25912 fail:
25913 return NULL;
25914 }
25915
25916
25917 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25918 PyObject *resultobj;
25919 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25920 wxDateSpan *arg2 = 0 ;
25921 wxDateSpan *result;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self",(char *) "other", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 {
25932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(2)) SWIG_fail;
25934 if (arg2 == NULL) {
25935 SWIG_null_ref("wxDateSpan");
25936 }
25937 if (SWIG_arg_fail(2)) SWIG_fail;
25938 }
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 {
25942 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25943 result = (wxDateSpan *) &_result_ref;
25944 }
25945
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25957 PyObject *resultobj;
25958 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25959 wxDateSpan *arg2 = 0 ;
25960 wxDateSpan *result;
25961 PyObject * obj0 = 0 ;
25962 PyObject * obj1 = 0 ;
25963 char *kwnames[] = {
25964 (char *) "self",(char *) "other", NULL
25965 };
25966
25967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25969 if (SWIG_arg_fail(1)) SWIG_fail;
25970 {
25971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25972 if (SWIG_arg_fail(2)) SWIG_fail;
25973 if (arg2 == NULL) {
25974 SWIG_null_ref("wxDateSpan");
25975 }
25976 if (SWIG_arg_fail(2)) SWIG_fail;
25977 }
25978 {
25979 PyThreadState* __tstate = wxPyBeginAllowThreads();
25980 {
25981 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25982 result = (wxDateSpan *) &_result_ref;
25983 }
25984
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25996 PyObject *resultobj;
25997 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25998 wxDateSpan *result;
25999 PyObject * obj0 = 0 ;
26000 char *kwnames[] = {
26001 (char *) "self", NULL
26002 };
26003
26004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26006 if (SWIG_arg_fail(1)) SWIG_fail;
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 {
26010 wxDateSpan &_result_ref = (arg1)->Neg();
26011 result = (wxDateSpan *) &_result_ref;
26012 }
26013
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj;
26026 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26027 int arg2 ;
26028 wxDateSpan *result;
26029 PyObject * obj0 = 0 ;
26030 PyObject * obj1 = 0 ;
26031 char *kwnames[] = {
26032 (char *) "self",(char *) "factor", NULL
26033 };
26034
26035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26037 if (SWIG_arg_fail(1)) SWIG_fail;
26038 {
26039 arg2 = (int)(SWIG_As_int(obj1));
26040 if (SWIG_arg_fail(2)) SWIG_fail;
26041 }
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 {
26045 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26046 result = (wxDateSpan *) &_result_ref;
26047 }
26048
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26060 PyObject *resultobj;
26061 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26062 wxDateSpan *arg2 = 0 ;
26063 wxDateSpan *result;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "self",(char *) "other", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 {
26074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26075 if (SWIG_arg_fail(2)) SWIG_fail;
26076 if (arg2 == NULL) {
26077 SWIG_null_ref("wxDateSpan");
26078 }
26079 if (SWIG_arg_fail(2)) SWIG_fail;
26080 }
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 {
26084 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26085 result = (wxDateSpan *) &_result_ref;
26086 }
26087
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj;
26100 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26101 wxDateSpan *arg2 = 0 ;
26102 wxDateSpan *result;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 char *kwnames[] = {
26106 (char *) "self",(char *) "other", NULL
26107 };
26108
26109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26111 if (SWIG_arg_fail(1)) SWIG_fail;
26112 {
26113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26114 if (SWIG_arg_fail(2)) SWIG_fail;
26115 if (arg2 == NULL) {
26116 SWIG_null_ref("wxDateSpan");
26117 }
26118 if (SWIG_arg_fail(2)) SWIG_fail;
26119 }
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 {
26123 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26124 result = (wxDateSpan *) &_result_ref;
26125 }
26126
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj;
26139 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26140 wxDateSpan *result;
26141 PyObject * obj0 = 0 ;
26142 char *kwnames[] = {
26143 (char *) "self", NULL
26144 };
26145
26146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26148 if (SWIG_arg_fail(1)) SWIG_fail;
26149 {
26150 PyThreadState* __tstate = wxPyBeginAllowThreads();
26151 {
26152 wxDateSpan &_result_ref = (arg1)->operator -();
26153 result = (wxDateSpan *) &_result_ref;
26154 }
26155
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26167 PyObject *resultobj;
26168 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26169 int arg2 ;
26170 wxDateSpan *result;
26171 PyObject * obj0 = 0 ;
26172 PyObject * obj1 = 0 ;
26173 char *kwnames[] = {
26174 (char *) "self",(char *) "factor", NULL
26175 };
26176
26177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26179 if (SWIG_arg_fail(1)) SWIG_fail;
26180 {
26181 arg2 = (int)(SWIG_As_int(obj1));
26182 if (SWIG_arg_fail(2)) SWIG_fail;
26183 }
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 {
26187 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26188 result = (wxDateSpan *) &_result_ref;
26189 }
26190
26191 wxPyEndAllowThreads(__tstate);
26192 if (PyErr_Occurred()) SWIG_fail;
26193 }
26194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj;
26203 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26204 wxDateSpan *arg2 = 0 ;
26205 wxDateSpan result;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char *kwnames[] = {
26209 (char *) "self",(char *) "other", NULL
26210 };
26211
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26214 if (SWIG_arg_fail(1)) SWIG_fail;
26215 {
26216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26217 if (SWIG_arg_fail(2)) SWIG_fail;
26218 if (arg2 == NULL) {
26219 SWIG_null_ref("wxDateSpan");
26220 }
26221 if (SWIG_arg_fail(2)) SWIG_fail;
26222 }
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26226
26227 wxPyEndAllowThreads(__tstate);
26228 if (PyErr_Occurred()) SWIG_fail;
26229 }
26230 {
26231 wxDateSpan * resultptr;
26232 resultptr = new wxDateSpan((wxDateSpan &)(result));
26233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26234 }
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26242 PyObject *resultobj;
26243 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26244 wxDateSpan *arg2 = 0 ;
26245 wxDateSpan result;
26246 PyObject * obj0 = 0 ;
26247 PyObject * obj1 = 0 ;
26248 char *kwnames[] = {
26249 (char *) "self",(char *) "other", NULL
26250 };
26251
26252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26254 if (SWIG_arg_fail(1)) SWIG_fail;
26255 {
26256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26257 if (SWIG_arg_fail(2)) SWIG_fail;
26258 if (arg2 == NULL) {
26259 SWIG_null_ref("wxDateSpan");
26260 }
26261 if (SWIG_arg_fail(2)) SWIG_fail;
26262 }
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26266
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 {
26271 wxDateSpan * resultptr;
26272 resultptr = new wxDateSpan((wxDateSpan &)(result));
26273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26274 }
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26284 int arg2 ;
26285 wxDateSpan result;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char *kwnames[] = {
26289 (char *) "self",(char *) "n", NULL
26290 };
26291
26292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26294 if (SWIG_arg_fail(1)) SWIG_fail;
26295 {
26296 arg2 = (int)(SWIG_As_int(obj1));
26297 if (SWIG_arg_fail(2)) SWIG_fail;
26298 }
26299 {
26300 PyThreadState* __tstate = wxPyBeginAllowThreads();
26301 result = wxDateSpan___mul__(arg1,arg2);
26302
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 {
26307 wxDateSpan * resultptr;
26308 resultptr = new wxDateSpan((wxDateSpan &)(result));
26309 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26310 }
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26318 PyObject *resultobj;
26319 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26320 int arg2 ;
26321 wxDateSpan result;
26322 PyObject * obj0 = 0 ;
26323 PyObject * obj1 = 0 ;
26324 char *kwnames[] = {
26325 (char *) "self",(char *) "n", NULL
26326 };
26327
26328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26330 if (SWIG_arg_fail(1)) SWIG_fail;
26331 {
26332 arg2 = (int)(SWIG_As_int(obj1));
26333 if (SWIG_arg_fail(2)) SWIG_fail;
26334 }
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 result = wxDateSpan___rmul__(arg1,arg2);
26338
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 wxDateSpan * resultptr;
26344 resultptr = new wxDateSpan((wxDateSpan &)(result));
26345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26346 }
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj;
26355 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26356 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26357 bool result;
26358 PyObject * obj0 = 0 ;
26359 PyObject * obj1 = 0 ;
26360 char *kwnames[] = {
26361 (char *) "self",(char *) "other", NULL
26362 };
26363
26364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26366 if (SWIG_arg_fail(1)) SWIG_fail;
26367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26368 if (SWIG_arg_fail(2)) SWIG_fail;
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26372
26373 wxPyEndAllowThreads(__tstate);
26374 if (PyErr_Occurred()) SWIG_fail;
26375 }
26376 {
26377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj;
26387 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26388 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26389 bool result;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char *kwnames[] = {
26393 (char *) "self",(char *) "other", NULL
26394 };
26395
26396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(1)) SWIG_fail;
26399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26400 if (SWIG_arg_fail(2)) SWIG_fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26404
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 {
26409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26410 }
26411 return resultobj;
26412 fail:
26413 return NULL;
26414 }
26415
26416
26417 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26418 PyObject *obj;
26419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26420 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26421 Py_INCREF(obj);
26422 return Py_BuildValue((char *)"");
26423 }
26424 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26425 PyObject *resultobj;
26426 long result;
26427 char *kwnames[] = {
26428 NULL
26429 };
26430
26431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 result = (long)wxGetLocalTime();
26435
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 {
26440 resultobj = SWIG_From_long((long)(result));
26441 }
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26449 PyObject *resultobj;
26450 long result;
26451 char *kwnames[] = {
26452 NULL
26453 };
26454
26455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 result = (long)wxGetUTCTime();
26459
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 {
26464 resultobj = SWIG_From_long((long)(result));
26465 }
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26473 PyObject *resultobj;
26474 long result;
26475 char *kwnames[] = {
26476 NULL
26477 };
26478
26479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = (long)wxGetCurrentTime();
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 {
26488 resultobj = SWIG_From_long((long)(result));
26489 }
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj;
26498 wxLongLong result;
26499 char *kwnames[] = {
26500 NULL
26501 };
26502
26503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 result = wxGetLocalTimeMillis();
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 {
26512 PyObject *hi, *lo, *shifter, *shifted;
26513 hi = PyLong_FromLong( (&result)->GetHi() );
26514 lo = PyLong_FromLong( (&result)->GetLo() );
26515 shifter = PyLong_FromLong(32);
26516 shifted = PyNumber_Lshift(hi, shifter);
26517 resultobj = PyNumber_Or(shifted, lo);
26518 Py_DECREF(hi);
26519 Py_DECREF(lo);
26520 Py_DECREF(shifter);
26521 Py_DECREF(shifted);
26522 }
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 static int _wrap_DefaultDateTime_set(PyObject *) {
26530 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26531 return 1;
26532 }
26533
26534
26535 static PyObject *_wrap_DefaultDateTime_get(void) {
26536 PyObject *pyobj;
26537
26538 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26539 return pyobj;
26540 }
26541
26542
26543 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26544 PyObject *resultobj;
26545 wxDataFormatId arg1 ;
26546 wxDataFormat *result;
26547 PyObject * obj0 = 0 ;
26548 char *kwnames[] = {
26549 (char *) "type", NULL
26550 };
26551
26552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26553 {
26554 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26555 if (SWIG_arg_fail(1)) SWIG_fail;
26556 }
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26560
26561 wxPyEndAllowThreads(__tstate);
26562 if (PyErr_Occurred()) SWIG_fail;
26563 }
26564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26565 return resultobj;
26566 fail:
26567 return NULL;
26568 }
26569
26570
26571 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj;
26573 wxString *arg1 = 0 ;
26574 wxDataFormat *result;
26575 bool temp1 = false ;
26576 PyObject * obj0 = 0 ;
26577 char *kwnames[] = {
26578 (char *) "format", NULL
26579 };
26580
26581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26582 {
26583 arg1 = wxString_in_helper(obj0);
26584 if (arg1 == NULL) SWIG_fail;
26585 temp1 = true;
26586 }
26587 {
26588 PyThreadState* __tstate = wxPyBeginAllowThreads();
26589 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26590
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26595 {
26596 if (temp1)
26597 delete arg1;
26598 }
26599 return resultobj;
26600 fail:
26601 {
26602 if (temp1)
26603 delete arg1;
26604 }
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26612 PyObject * obj0 = 0 ;
26613 char *kwnames[] = {
26614 (char *) "self", NULL
26615 };
26616
26617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26619 if (SWIG_arg_fail(1)) SWIG_fail;
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 delete arg1;
26623
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 Py_INCREF(Py_None); resultobj = Py_None;
26628 return resultobj;
26629 fail:
26630 return NULL;
26631 }
26632
26633
26634 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26635 PyObject *resultobj;
26636 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26637 wxDataFormatId arg2 ;
26638 bool result;
26639 PyObject * obj0 = 0 ;
26640 PyObject * obj1 = 0 ;
26641
26642 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26644 if (SWIG_arg_fail(1)) SWIG_fail;
26645 {
26646 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26647 if (SWIG_arg_fail(2)) SWIG_fail;
26648 }
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26652
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 {
26657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26658 }
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26666 PyObject *resultobj;
26667 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26668 wxDataFormatId arg2 ;
26669 bool result;
26670 PyObject * obj0 = 0 ;
26671 PyObject * obj1 = 0 ;
26672
26673 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26675 if (SWIG_arg_fail(1)) SWIG_fail;
26676 {
26677 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26678 if (SWIG_arg_fail(2)) SWIG_fail;
26679 }
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26683
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 {
26688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26689 }
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26697 PyObject *resultobj;
26698 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26699 wxDataFormat *arg2 = 0 ;
26700 bool result;
26701 PyObject * obj0 = 0 ;
26702 PyObject * obj1 = 0 ;
26703
26704 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26709 if (SWIG_arg_fail(2)) SWIG_fail;
26710 if (arg2 == NULL) {
26711 SWIG_null_ref("wxDataFormat");
26712 }
26713 if (SWIG_arg_fail(2)) SWIG_fail;
26714 }
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26718
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26732 int argc;
26733 PyObject *argv[3];
26734 int ii;
26735
26736 argc = PyObject_Length(args);
26737 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26738 argv[ii] = PyTuple_GetItem(args,ii);
26739 }
26740 if (argc == 2) {
26741 int _v;
26742 {
26743 void *ptr;
26744 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26745 _v = 0;
26746 PyErr_Clear();
26747 } else {
26748 _v = 1;
26749 }
26750 }
26751 if (_v) {
26752 {
26753 void *ptr = 0;
26754 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26755 _v = 0;
26756 PyErr_Clear();
26757 } else {
26758 _v = (ptr != 0);
26759 }
26760 }
26761 if (_v) {
26762 return _wrap_DataFormat___eq____SWIG_1(self,args);
26763 }
26764 }
26765 }
26766 if (argc == 2) {
26767 int _v;
26768 {
26769 void *ptr;
26770 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26771 _v = 0;
26772 PyErr_Clear();
26773 } else {
26774 _v = 1;
26775 }
26776 }
26777 if (_v) {
26778 _v = SWIG_Check_int(argv[1]);
26779 if (_v) {
26780 return _wrap_DataFormat___eq____SWIG_0(self,args);
26781 }
26782 }
26783 }
26784
26785 Py_INCREF(Py_NotImplemented);
26786 return Py_NotImplemented;
26787 }
26788
26789
26790 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26791 PyObject *resultobj;
26792 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26793 wxDataFormat *arg2 = 0 ;
26794 bool result;
26795 PyObject * obj0 = 0 ;
26796 PyObject * obj1 = 0 ;
26797
26798 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26800 if (SWIG_arg_fail(1)) SWIG_fail;
26801 {
26802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26803 if (SWIG_arg_fail(2)) SWIG_fail;
26804 if (arg2 == NULL) {
26805 SWIG_null_ref("wxDataFormat");
26806 }
26807 if (SWIG_arg_fail(2)) SWIG_fail;
26808 }
26809 {
26810 PyThreadState* __tstate = wxPyBeginAllowThreads();
26811 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26812
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 {
26817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26818 }
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26826 int argc;
26827 PyObject *argv[3];
26828 int ii;
26829
26830 argc = PyObject_Length(args);
26831 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26832 argv[ii] = PyTuple_GetItem(args,ii);
26833 }
26834 if (argc == 2) {
26835 int _v;
26836 {
26837 void *ptr;
26838 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26839 _v = 0;
26840 PyErr_Clear();
26841 } else {
26842 _v = 1;
26843 }
26844 }
26845 if (_v) {
26846 {
26847 void *ptr = 0;
26848 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26849 _v = 0;
26850 PyErr_Clear();
26851 } else {
26852 _v = (ptr != 0);
26853 }
26854 }
26855 if (_v) {
26856 return _wrap_DataFormat___ne____SWIG_1(self,args);
26857 }
26858 }
26859 }
26860 if (argc == 2) {
26861 int _v;
26862 {
26863 void *ptr;
26864 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26865 _v = 0;
26866 PyErr_Clear();
26867 } else {
26868 _v = 1;
26869 }
26870 }
26871 if (_v) {
26872 _v = SWIG_Check_int(argv[1]);
26873 if (_v) {
26874 return _wrap_DataFormat___ne____SWIG_0(self,args);
26875 }
26876 }
26877 }
26878
26879 Py_INCREF(Py_NotImplemented);
26880 return Py_NotImplemented;
26881 }
26882
26883
26884 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26885 PyObject *resultobj;
26886 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26887 wxDataFormatId arg2 ;
26888 PyObject * obj0 = 0 ;
26889 PyObject * obj1 = 0 ;
26890 char *kwnames[] = {
26891 (char *) "self",(char *) "format", NULL
26892 };
26893
26894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26896 if (SWIG_arg_fail(1)) SWIG_fail;
26897 {
26898 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26899 if (SWIG_arg_fail(2)) SWIG_fail;
26900 }
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 (arg1)->SetType((wxDataFormatId )arg2);
26904
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 Py_INCREF(Py_None); resultobj = Py_None;
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26916 PyObject *resultobj;
26917 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26918 wxDataFormatId result;
26919 PyObject * obj0 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_From_int((result));
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj;
26943 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26944 wxString result;
26945 PyObject * obj0 = 0 ;
26946 char *kwnames[] = {
26947 (char *) "self", NULL
26948 };
26949
26950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26952 if (SWIG_arg_fail(1)) SWIG_fail;
26953 {
26954 PyThreadState* __tstate = wxPyBeginAllowThreads();
26955 result = ((wxDataFormat const *)arg1)->GetId();
26956
26957 wxPyEndAllowThreads(__tstate);
26958 if (PyErr_Occurred()) SWIG_fail;
26959 }
26960 {
26961 #if wxUSE_UNICODE
26962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26963 #else
26964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26965 #endif
26966 }
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj;
26975 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26976 wxString *arg2 = 0 ;
26977 bool temp2 = false ;
26978 PyObject * obj0 = 0 ;
26979 PyObject * obj1 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self",(char *) "format", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 {
26988 arg2 = wxString_in_helper(obj1);
26989 if (arg2 == NULL) SWIG_fail;
26990 temp2 = true;
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 (arg1)->SetId((wxString const &)*arg2);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 Py_INCREF(Py_None); resultobj = Py_None;
27000 {
27001 if (temp2)
27002 delete arg2;
27003 }
27004 return resultobj;
27005 fail:
27006 {
27007 if (temp2)
27008 delete arg2;
27009 }
27010 return NULL;
27011 }
27012
27013
27014 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27015 PyObject *obj;
27016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27017 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27018 Py_INCREF(obj);
27019 return Py_BuildValue((char *)"");
27020 }
27021 static int _wrap_FormatInvalid_set(PyObject *) {
27022 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27023 return 1;
27024 }
27025
27026
27027 static PyObject *_wrap_FormatInvalid_get(void) {
27028 PyObject *pyobj;
27029
27030 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27031 return pyobj;
27032 }
27033
27034
27035 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27036 PyObject *resultobj;
27037 wxDataObject *arg1 = (wxDataObject *) 0 ;
27038 PyObject * obj0 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 delete arg1;
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 Py_INCREF(Py_None); resultobj = Py_None;
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27061 PyObject *resultobj;
27062 wxDataObject *arg1 = (wxDataObject *) 0 ;
27063 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27064 SwigValueWrapper<wxDataFormat > result;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char *kwnames[] = {
27068 (char *) "self",(char *) "dir", NULL
27069 };
27070
27071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(1)) SWIG_fail;
27074 if (obj1) {
27075 {
27076 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27077 if (SWIG_arg_fail(2)) SWIG_fail;
27078 }
27079 }
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27083
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 {
27088 wxDataFormat * resultptr;
27089 resultptr = new wxDataFormat((wxDataFormat &)(result));
27090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27091 }
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj;
27100 wxDataObject *arg1 = (wxDataObject *) 0 ;
27101 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27102 size_t result;
27103 PyObject * obj0 = 0 ;
27104 PyObject * obj1 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self",(char *) "dir", NULL
27107 };
27108
27109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 if (obj1) {
27113 {
27114 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27115 if (SWIG_arg_fail(2)) SWIG_fail;
27116 }
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27121
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27127 }
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27135 PyObject *resultobj;
27136 wxDataObject *arg1 = (wxDataObject *) 0 ;
27137 wxDataFormat *arg2 = 0 ;
27138 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27139 bool result;
27140 PyObject * obj0 = 0 ;
27141 PyObject * obj1 = 0 ;
27142 PyObject * obj2 = 0 ;
27143 char *kwnames[] = {
27144 (char *) "self",(char *) "format",(char *) "dir", NULL
27145 };
27146
27147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27149 if (SWIG_arg_fail(1)) SWIG_fail;
27150 {
27151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27152 if (SWIG_arg_fail(2)) SWIG_fail;
27153 if (arg2 == NULL) {
27154 SWIG_null_ref("wxDataFormat");
27155 }
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 }
27158 if (obj2) {
27159 {
27160 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27161 if (SWIG_arg_fail(3)) SWIG_fail;
27162 }
27163 }
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxDataObject *arg1 = (wxDataObject *) 0 ;
27183 wxDataFormat *arg2 = 0 ;
27184 size_t result;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 char *kwnames[] = {
27188 (char *) "self",(char *) "format", NULL
27189 };
27190
27191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27193 if (SWIG_arg_fail(1)) SWIG_fail;
27194 {
27195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27196 if (SWIG_arg_fail(2)) SWIG_fail;
27197 if (arg2 == NULL) {
27198 SWIG_null_ref("wxDataFormat");
27199 }
27200 if (SWIG_arg_fail(2)) SWIG_fail;
27201 }
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27205
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 {
27210 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27211 }
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27219 PyObject *resultobj;
27220 wxDataObject *arg1 = (wxDataObject *) 0 ;
27221 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27222 PyObject *result;
27223 PyObject * obj0 = 0 ;
27224 PyObject * obj1 = 0 ;
27225 char *kwnames[] = {
27226 (char *) "self",(char *) "dir", NULL
27227 };
27228
27229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27231 if (SWIG_arg_fail(1)) SWIG_fail;
27232 if (obj1) {
27233 {
27234 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27235 if (SWIG_arg_fail(2)) SWIG_fail;
27236 }
27237 }
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27241
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 resultobj = result;
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27253 PyObject *resultobj;
27254 wxDataObject *arg1 = (wxDataObject *) 0 ;
27255 wxDataFormat *arg2 = 0 ;
27256 PyObject *result;
27257 PyObject * obj0 = 0 ;
27258 PyObject * obj1 = 0 ;
27259 char *kwnames[] = {
27260 (char *) "self",(char *) "format", NULL
27261 };
27262
27263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27265 if (SWIG_arg_fail(1)) SWIG_fail;
27266 {
27267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27268 if (SWIG_arg_fail(2)) SWIG_fail;
27269 if (arg2 == NULL) {
27270 SWIG_null_ref("wxDataFormat");
27271 }
27272 if (SWIG_arg_fail(2)) SWIG_fail;
27273 }
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = result;
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj;
27290 wxDataObject *arg1 = (wxDataObject *) 0 ;
27291 wxDataFormat *arg2 = 0 ;
27292 PyObject *arg3 = (PyObject *) 0 ;
27293 bool result;
27294 PyObject * obj0 = 0 ;
27295 PyObject * obj1 = 0 ;
27296 PyObject * obj2 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self",(char *) "format",(char *) "data", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(2)) SWIG_fail;
27307 if (arg2 == NULL) {
27308 SWIG_null_ref("wxDataFormat");
27309 }
27310 if (SWIG_arg_fail(2)) SWIG_fail;
27311 }
27312 arg3 = obj2;
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27316
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 {
27321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27322 }
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27330 PyObject *obj;
27331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27332 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27333 Py_INCREF(obj);
27334 return Py_BuildValue((char *)"");
27335 }
27336 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27337 PyObject *resultobj;
27338 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27339 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27340 wxDataObjectSimple *result;
27341 PyObject * obj0 = 0 ;
27342 char *kwnames[] = {
27343 (char *) "format", NULL
27344 };
27345
27346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27347 if (obj0) {
27348 {
27349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27350 if (SWIG_arg_fail(1)) SWIG_fail;
27351 if (arg1 == NULL) {
27352 SWIG_null_ref("wxDataFormat");
27353 }
27354 if (SWIG_arg_fail(1)) SWIG_fail;
27355 }
27356 }
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj;
27373 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27374 wxDataFormat *result;
27375 PyObject * obj0 = 0 ;
27376 char *kwnames[] = {
27377 (char *) "self", NULL
27378 };
27379
27380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(1)) SWIG_fail;
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 {
27386 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27387 result = (wxDataFormat *) &_result_ref;
27388 }
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj;
27402 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27403 wxDataFormat *arg2 = 0 ;
27404 PyObject * obj0 = 0 ;
27405 PyObject * obj1 = 0 ;
27406 char *kwnames[] = {
27407 (char *) "self",(char *) "format", NULL
27408 };
27409
27410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27412 if (SWIG_arg_fail(1)) SWIG_fail;
27413 {
27414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27415 if (SWIG_arg_fail(2)) SWIG_fail;
27416 if (arg2 == NULL) {
27417 SWIG_null_ref("wxDataFormat");
27418 }
27419 if (SWIG_arg_fail(2)) SWIG_fail;
27420 }
27421 {
27422 PyThreadState* __tstate = wxPyBeginAllowThreads();
27423 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27424
27425 wxPyEndAllowThreads(__tstate);
27426 if (PyErr_Occurred()) SWIG_fail;
27427 }
27428 Py_INCREF(Py_None); resultobj = Py_None;
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj;
27437 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27438 size_t result;
27439 PyObject * obj0 = 0 ;
27440 char *kwnames[] = {
27441 (char *) "self", NULL
27442 };
27443
27444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27446 if (SWIG_arg_fail(1)) SWIG_fail;
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27450
27451 wxPyEndAllowThreads(__tstate);
27452 if (PyErr_Occurred()) SWIG_fail;
27453 }
27454 {
27455 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27456 }
27457 return resultobj;
27458 fail:
27459 return NULL;
27460 }
27461
27462
27463 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj;
27465 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27466 PyObject *result;
27467 PyObject * obj0 = 0 ;
27468 char *kwnames[] = {
27469 (char *) "self", NULL
27470 };
27471
27472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27474 if (SWIG_arg_fail(1)) SWIG_fail;
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27478
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = result;
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27492 PyObject *arg2 = (PyObject *) 0 ;
27493 bool result;
27494 PyObject * obj0 = 0 ;
27495 PyObject * obj1 = 0 ;
27496 char *kwnames[] = {
27497 (char *) "self",(char *) "data", NULL
27498 };
27499
27500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27502 if (SWIG_arg_fail(1)) SWIG_fail;
27503 arg2 = obj1;
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27507
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 {
27512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27513 }
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27521 PyObject *obj;
27522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27523 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27524 Py_INCREF(obj);
27525 return Py_BuildValue((char *)"");
27526 }
27527 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj;
27529 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27530 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27531 wxPyDataObjectSimple *result;
27532 PyObject * obj0 = 0 ;
27533 char *kwnames[] = {
27534 (char *) "format", NULL
27535 };
27536
27537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27538 if (obj0) {
27539 {
27540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27541 if (SWIG_arg_fail(1)) SWIG_fail;
27542 if (arg1 == NULL) {
27543 SWIG_null_ref("wxDataFormat");
27544 }
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 }
27547 }
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj;
27564 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27565 PyObject *arg2 = (PyObject *) 0 ;
27566 PyObject *arg3 = (PyObject *) 0 ;
27567 PyObject * obj0 = 0 ;
27568 PyObject * obj1 = 0 ;
27569 PyObject * obj2 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "self",(char *) "_class", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 arg2 = obj1;
27578 arg3 = obj2;
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->_setCallbackInfo(arg2,arg3);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 Py_INCREF(Py_None); resultobj = Py_None;
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27594 PyObject *obj;
27595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27596 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27597 Py_INCREF(obj);
27598 return Py_BuildValue((char *)"");
27599 }
27600 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxDataObjectComposite *result;
27603 char *kwnames[] = {
27604 NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27611
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj;
27624 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27625 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27626 bool arg3 = (bool) false ;
27627 PyObject * obj0 = 0 ;
27628 PyObject * obj1 = 0 ;
27629 PyObject * obj2 = 0 ;
27630 char *kwnames[] = {
27631 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27632 };
27633
27634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27636 if (SWIG_arg_fail(1)) SWIG_fail;
27637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27638 if (SWIG_arg_fail(2)) SWIG_fail;
27639 if (obj2) {
27640 {
27641 arg3 = (bool)(SWIG_As_bool(obj2));
27642 if (SWIG_arg_fail(3)) SWIG_fail;
27643 }
27644 }
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 (arg1)->Add(arg2,arg3);
27648
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 Py_INCREF(Py_None); resultobj = Py_None;
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27660 PyObject *obj;
27661 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27662 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27663 Py_INCREF(obj);
27664 return Py_BuildValue((char *)"");
27665 }
27666 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxString const &arg1_defvalue = wxPyEmptyString ;
27669 wxString *arg1 = (wxString *) &arg1_defvalue ;
27670 wxTextDataObject *result;
27671 bool temp1 = false ;
27672 PyObject * obj0 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "text", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27678 if (obj0) {
27679 {
27680 arg1 = wxString_in_helper(obj0);
27681 if (arg1 == NULL) SWIG_fail;
27682 temp1 = true;
27683 }
27684 }
27685 {
27686 PyThreadState* __tstate = wxPyBeginAllowThreads();
27687 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27688
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27693 {
27694 if (temp1)
27695 delete arg1;
27696 }
27697 return resultobj;
27698 fail:
27699 {
27700 if (temp1)
27701 delete arg1;
27702 }
27703 return NULL;
27704 }
27705
27706
27707 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27708 PyObject *resultobj;
27709 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27710 size_t result;
27711 PyObject * obj0 = 0 ;
27712 char *kwnames[] = {
27713 (char *) "self", NULL
27714 };
27715
27716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27718 if (SWIG_arg_fail(1)) SWIG_fail;
27719 {
27720 PyThreadState* __tstate = wxPyBeginAllowThreads();
27721 result = (size_t)(arg1)->GetTextLength();
27722
27723 wxPyEndAllowThreads(__tstate);
27724 if (PyErr_Occurred()) SWIG_fail;
27725 }
27726 {
27727 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27728 }
27729 return resultobj;
27730 fail:
27731 return NULL;
27732 }
27733
27734
27735 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27736 PyObject *resultobj;
27737 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27738 wxString result;
27739 PyObject * obj0 = 0 ;
27740 char *kwnames[] = {
27741 (char *) "self", NULL
27742 };
27743
27744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27746 if (SWIG_arg_fail(1)) SWIG_fail;
27747 {
27748 PyThreadState* __tstate = wxPyBeginAllowThreads();
27749 result = (arg1)->GetText();
27750
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 #if wxUSE_UNICODE
27756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27757 #else
27758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27759 #endif
27760 }
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj;
27769 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27770 wxString *arg2 = 0 ;
27771 bool temp2 = false ;
27772 PyObject * obj0 = 0 ;
27773 PyObject * obj1 = 0 ;
27774 char *kwnames[] = {
27775 (char *) "self",(char *) "text", NULL
27776 };
27777
27778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27780 if (SWIG_arg_fail(1)) SWIG_fail;
27781 {
27782 arg2 = wxString_in_helper(obj1);
27783 if (arg2 == NULL) SWIG_fail;
27784 temp2 = true;
27785 }
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->SetText((wxString const &)*arg2);
27789
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 Py_INCREF(Py_None); resultobj = Py_None;
27794 {
27795 if (temp2)
27796 delete arg2;
27797 }
27798 return resultobj;
27799 fail:
27800 {
27801 if (temp2)
27802 delete arg2;
27803 }
27804 return NULL;
27805 }
27806
27807
27808 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27809 PyObject *obj;
27810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27811 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27812 Py_INCREF(obj);
27813 return Py_BuildValue((char *)"");
27814 }
27815 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxString const &arg1_defvalue = wxPyEmptyString ;
27818 wxString *arg1 = (wxString *) &arg1_defvalue ;
27819 wxPyTextDataObject *result;
27820 bool temp1 = false ;
27821 PyObject * obj0 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "text", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27827 if (obj0) {
27828 {
27829 arg1 = wxString_in_helper(obj0);
27830 if (arg1 == NULL) SWIG_fail;
27831 temp1 = true;
27832 }
27833 }
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27837
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27842 {
27843 if (temp1)
27844 delete arg1;
27845 }
27846 return resultobj;
27847 fail:
27848 {
27849 if (temp1)
27850 delete arg1;
27851 }
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27859 PyObject *arg2 = (PyObject *) 0 ;
27860 PyObject *arg3 = (PyObject *) 0 ;
27861 PyObject * obj0 = 0 ;
27862 PyObject * obj1 = 0 ;
27863 PyObject * obj2 = 0 ;
27864 char *kwnames[] = {
27865 (char *) "self",(char *) "self",(char *) "_class", NULL
27866 };
27867
27868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27870 if (SWIG_arg_fail(1)) SWIG_fail;
27871 arg2 = obj1;
27872 arg3 = obj2;
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 (arg1)->_setCallbackInfo(arg2,arg3);
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 Py_INCREF(Py_None); resultobj = Py_None;
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27888 PyObject *obj;
27889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27890 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27891 Py_INCREF(obj);
27892 return Py_BuildValue((char *)"");
27893 }
27894 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj;
27896 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27897 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27898 wxBitmapDataObject *result;
27899 PyObject * obj0 = 0 ;
27900 char *kwnames[] = {
27901 (char *) "bitmap", NULL
27902 };
27903
27904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27905 if (obj0) {
27906 {
27907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 if (arg1 == NULL) {
27910 SWIG_null_ref("wxBitmap");
27911 }
27912 if (SWIG_arg_fail(1)) SWIG_fail;
27913 }
27914 }
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27918
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27930 PyObject *resultobj;
27931 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27932 wxBitmap result;
27933 PyObject * obj0 = 0 ;
27934 char *kwnames[] = {
27935 (char *) "self", NULL
27936 };
27937
27938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 wxBitmap * resultptr;
27950 resultptr = new wxBitmap((wxBitmap &)(result));
27951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj;
27961 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27962 wxBitmap *arg2 = 0 ;
27963 PyObject * obj0 = 0 ;
27964 PyObject * obj1 = 0 ;
27965 char *kwnames[] = {
27966 (char *) "self",(char *) "bitmap", NULL
27967 };
27968
27969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 {
27973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(2)) SWIG_fail;
27975 if (arg2 == NULL) {
27976 SWIG_null_ref("wxBitmap");
27977 }
27978 if (SWIG_arg_fail(2)) SWIG_fail;
27979 }
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27983
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 Py_INCREF(Py_None); resultobj = Py_None;
27988 return resultobj;
27989 fail:
27990 return NULL;
27991 }
27992
27993
27994 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27995 PyObject *obj;
27996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27997 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27998 Py_INCREF(obj);
27999 return Py_BuildValue((char *)"");
28000 }
28001 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28002 PyObject *resultobj;
28003 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28004 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28005 wxPyBitmapDataObject *result;
28006 PyObject * obj0 = 0 ;
28007 char *kwnames[] = {
28008 (char *) "bitmap", NULL
28009 };
28010
28011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28012 if (obj0) {
28013 {
28014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28015 if (SWIG_arg_fail(1)) SWIG_fail;
28016 if (arg1 == NULL) {
28017 SWIG_null_ref("wxBitmap");
28018 }
28019 if (SWIG_arg_fail(1)) SWIG_fail;
28020 }
28021 }
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28025
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj;
28038 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28039 PyObject *arg2 = (PyObject *) 0 ;
28040 PyObject *arg3 = (PyObject *) 0 ;
28041 PyObject * obj0 = 0 ;
28042 PyObject * obj1 = 0 ;
28043 PyObject * obj2 = 0 ;
28044 char *kwnames[] = {
28045 (char *) "self",(char *) "self",(char *) "_class", NULL
28046 };
28047
28048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28050 if (SWIG_arg_fail(1)) SWIG_fail;
28051 arg2 = obj1;
28052 arg3 = obj2;
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 (arg1)->_setCallbackInfo(arg2,arg3);
28056
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 Py_INCREF(Py_None); resultobj = Py_None;
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28068 PyObject *obj;
28069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28070 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28071 Py_INCREF(obj);
28072 return Py_BuildValue((char *)"");
28073 }
28074 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxFileDataObject *result;
28077 char *kwnames[] = {
28078 NULL
28079 };
28080
28081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (wxFileDataObject *)new wxFileDataObject();
28085
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj;
28098 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28099 wxArrayString *result;
28100 PyObject * obj0 = 0 ;
28101 char *kwnames[] = {
28102 (char *) "self", NULL
28103 };
28104
28105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28107 if (SWIG_arg_fail(1)) SWIG_fail;
28108 {
28109 PyThreadState* __tstate = wxPyBeginAllowThreads();
28110 {
28111 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28112 result = (wxArrayString *) &_result_ref;
28113 }
28114
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 {
28119 resultobj = wxArrayString2PyList_helper(*result);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj;
28129 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28130 wxString *arg2 = 0 ;
28131 bool temp2 = false ;
28132 PyObject * obj0 = 0 ;
28133 PyObject * obj1 = 0 ;
28134 char *kwnames[] = {
28135 (char *) "self",(char *) "filename", NULL
28136 };
28137
28138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28140 if (SWIG_arg_fail(1)) SWIG_fail;
28141 {
28142 arg2 = wxString_in_helper(obj1);
28143 if (arg2 == NULL) SWIG_fail;
28144 temp2 = true;
28145 }
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 (arg1)->AddFile((wxString const &)*arg2);
28149
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 Py_INCREF(Py_None); resultobj = Py_None;
28154 {
28155 if (temp2)
28156 delete arg2;
28157 }
28158 return resultobj;
28159 fail:
28160 {
28161 if (temp2)
28162 delete arg2;
28163 }
28164 return NULL;
28165 }
28166
28167
28168 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28169 PyObject *obj;
28170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28171 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28172 Py_INCREF(obj);
28173 return Py_BuildValue((char *)"");
28174 }
28175 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28176 PyObject *resultobj;
28177 wxDataFormat *arg1 = 0 ;
28178 wxCustomDataObject *result;
28179 PyObject * obj0 = 0 ;
28180
28181 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28182 {
28183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28184 if (SWIG_arg_fail(1)) SWIG_fail;
28185 if (arg1 == NULL) {
28186 SWIG_null_ref("wxDataFormat");
28187 }
28188 if (SWIG_arg_fail(1)) SWIG_fail;
28189 }
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28193
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28205 PyObject *resultobj;
28206 wxString *arg1 = 0 ;
28207 wxCustomDataObject *result;
28208 bool temp1 = false ;
28209 PyObject * obj0 = 0 ;
28210
28211 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28212 {
28213 arg1 = wxString_in_helper(obj0);
28214 if (arg1 == NULL) SWIG_fail;
28215 temp1 = true;
28216 }
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28220
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28225 {
28226 if (temp1)
28227 delete arg1;
28228 }
28229 return resultobj;
28230 fail:
28231 {
28232 if (temp1)
28233 delete arg1;
28234 }
28235 return NULL;
28236 }
28237
28238
28239 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28240 PyObject *resultobj;
28241 wxCustomDataObject *result;
28242
28243 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (wxCustomDataObject *)new wxCustomDataObject();
28247
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28259 int argc;
28260 PyObject *argv[2];
28261 int ii;
28262
28263 argc = PyObject_Length(args);
28264 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28265 argv[ii] = PyTuple_GetItem(args,ii);
28266 }
28267 if (argc == 0) {
28268 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28269 }
28270 if (argc == 1) {
28271 int _v;
28272 {
28273 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28274 }
28275 if (_v) {
28276 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28277 }
28278 }
28279 if (argc == 1) {
28280 int _v;
28281 {
28282 void *ptr = 0;
28283 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28284 _v = 0;
28285 PyErr_Clear();
28286 } else {
28287 _v = (ptr != 0);
28288 }
28289 }
28290 if (_v) {
28291 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28292 }
28293 }
28294
28295 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28296 return NULL;
28297 }
28298
28299
28300 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28301 PyObject *resultobj;
28302 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28303 PyObject *arg2 = (PyObject *) 0 ;
28304 bool result;
28305 PyObject * obj0 = 0 ;
28306 PyObject * obj1 = 0 ;
28307 char *kwnames[] = {
28308 (char *) "self",(char *) "data", NULL
28309 };
28310
28311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28313 if (SWIG_arg_fail(1)) SWIG_fail;
28314 arg2 = obj1;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28318
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 {
28323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28324 }
28325 return resultobj;
28326 fail:
28327 return NULL;
28328 }
28329
28330
28331 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj;
28333 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28334 size_t result;
28335 PyObject * obj0 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (size_t)(arg1)->GetSize();
28346
28347 wxPyEndAllowThreads(__tstate);
28348 if (PyErr_Occurred()) SWIG_fail;
28349 }
28350 {
28351 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28352 }
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28362 PyObject *result;
28363 PyObject * obj0 = 0 ;
28364 char *kwnames[] = {
28365 (char *) "self", NULL
28366 };
28367
28368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28370 if (SWIG_arg_fail(1)) SWIG_fail;
28371 {
28372 PyThreadState* __tstate = wxPyBeginAllowThreads();
28373 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28374
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 resultobj = result;
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28386 PyObject *obj;
28387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28388 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28389 Py_INCREF(obj);
28390 return Py_BuildValue((char *)"");
28391 }
28392 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28393 PyObject *resultobj;
28394 wxURLDataObject *result;
28395 char *kwnames[] = {
28396 NULL
28397 };
28398
28399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = (wxURLDataObject *)new wxURLDataObject();
28403
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj;
28416 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28417 wxString result;
28418 PyObject * obj0 = 0 ;
28419 char *kwnames[] = {
28420 (char *) "self", NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28425 if (SWIG_arg_fail(1)) SWIG_fail;
28426 {
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = (arg1)->GetURL();
28429
28430 wxPyEndAllowThreads(__tstate);
28431 if (PyErr_Occurred()) SWIG_fail;
28432 }
28433 {
28434 #if wxUSE_UNICODE
28435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28436 #else
28437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28438 #endif
28439 }
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj;
28448 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28449 wxString *arg2 = 0 ;
28450 bool temp2 = false ;
28451 PyObject * obj0 = 0 ;
28452 PyObject * obj1 = 0 ;
28453 char *kwnames[] = {
28454 (char *) "self",(char *) "url", NULL
28455 };
28456
28457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28459 if (SWIG_arg_fail(1)) SWIG_fail;
28460 {
28461 arg2 = wxString_in_helper(obj1);
28462 if (arg2 == NULL) SWIG_fail;
28463 temp2 = true;
28464 }
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 (arg1)->SetURL((wxString const &)*arg2);
28468
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 Py_INCREF(Py_None); resultobj = Py_None;
28473 {
28474 if (temp2)
28475 delete arg2;
28476 }
28477 return resultobj;
28478 fail:
28479 {
28480 if (temp2)
28481 delete arg2;
28482 }
28483 return NULL;
28484 }
28485
28486
28487 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28488 PyObject *obj;
28489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28490 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28491 Py_INCREF(obj);
28492 return Py_BuildValue((char *)"");
28493 }
28494 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28495 PyObject *resultobj;
28496 wxMetafileDataObject *result;
28497 char *kwnames[] = {
28498 NULL
28499 };
28500
28501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28505
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28517 PyObject *resultobj;
28518 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28519 wxMetafile *arg2 = 0 ;
28520 PyObject * obj0 = 0 ;
28521 PyObject * obj1 = 0 ;
28522 char *kwnames[] = {
28523 (char *) "self",(char *) "metafile", NULL
28524 };
28525
28526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28528 if (SWIG_arg_fail(1)) SWIG_fail;
28529 {
28530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28531 if (SWIG_arg_fail(2)) SWIG_fail;
28532 if (arg2 == NULL) {
28533 SWIG_null_ref("wxMetafile");
28534 }
28535 if (SWIG_arg_fail(2)) SWIG_fail;
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 Py_INCREF(Py_None); resultobj = Py_None;
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj;
28553 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28554 wxMetafile result;
28555 PyObject * obj0 = 0 ;
28556 char *kwnames[] = {
28557 (char *) "self", NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28562 if (SWIG_arg_fail(1)) SWIG_fail;
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28566
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 {
28571 wxMetafile * resultptr;
28572 resultptr = new wxMetafile((wxMetafile &)(result));
28573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28574 }
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28582 PyObject *obj;
28583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28584 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28585 Py_INCREF(obj);
28586 return Py_BuildValue((char *)"");
28587 }
28588 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28589 PyObject *resultobj;
28590 wxDragResult arg1 ;
28591 bool result;
28592 PyObject * obj0 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "res", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28598 {
28599 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28600 if (SWIG_arg_fail(1)) SWIG_fail;
28601 }
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj;
28620 wxWindow *arg1 = (wxWindow *) 0 ;
28621 wxCursor const &arg2_defvalue = wxNullCursor ;
28622 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28623 wxCursor const &arg3_defvalue = wxNullCursor ;
28624 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28625 wxCursor const &arg4_defvalue = wxNullCursor ;
28626 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28627 wxPyDropSource *result;
28628 PyObject * obj0 = 0 ;
28629 PyObject * obj1 = 0 ;
28630 PyObject * obj2 = 0 ;
28631 PyObject * obj3 = 0 ;
28632 char *kwnames[] = {
28633 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28634 };
28635
28636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 if (obj1) {
28640 {
28641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28642 if (SWIG_arg_fail(2)) SWIG_fail;
28643 if (arg2 == NULL) {
28644 SWIG_null_ref("wxCursor");
28645 }
28646 if (SWIG_arg_fail(2)) SWIG_fail;
28647 }
28648 }
28649 if (obj2) {
28650 {
28651 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28652 if (SWIG_arg_fail(3)) SWIG_fail;
28653 if (arg3 == NULL) {
28654 SWIG_null_ref("wxCursor");
28655 }
28656 if (SWIG_arg_fail(3)) SWIG_fail;
28657 }
28658 }
28659 if (obj3) {
28660 {
28661 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28662 if (SWIG_arg_fail(4)) SWIG_fail;
28663 if (arg4 == NULL) {
28664 SWIG_null_ref("wxCursor");
28665 }
28666 if (SWIG_arg_fail(4)) SWIG_fail;
28667 }
28668 }
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28672
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28684 PyObject *resultobj;
28685 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28686 PyObject *arg2 = (PyObject *) 0 ;
28687 PyObject *arg3 = (PyObject *) 0 ;
28688 int arg4 ;
28689 PyObject * obj0 = 0 ;
28690 PyObject * obj1 = 0 ;
28691 PyObject * obj2 = 0 ;
28692 PyObject * obj3 = 0 ;
28693 char *kwnames[] = {
28694 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28695 };
28696
28697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28699 if (SWIG_arg_fail(1)) SWIG_fail;
28700 arg2 = obj1;
28701 arg3 = obj2;
28702 {
28703 arg4 = (int)(SWIG_As_int(obj3));
28704 if (SWIG_arg_fail(4)) SWIG_fail;
28705 }
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28709
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 Py_INCREF(Py_None); resultobj = Py_None;
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28721 PyObject *resultobj;
28722 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28723 PyObject * obj0 = 0 ;
28724 char *kwnames[] = {
28725 (char *) "self", NULL
28726 };
28727
28728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28730 if (SWIG_arg_fail(1)) SWIG_fail;
28731 {
28732 PyThreadState* __tstate = wxPyBeginAllowThreads();
28733 delete arg1;
28734
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 Py_INCREF(Py_None); resultobj = Py_None;
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28746 PyObject *resultobj;
28747 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28748 wxDataObject *arg2 = 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 char *kwnames[] = {
28752 (char *) "self",(char *) "data", NULL
28753 };
28754
28755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28757 if (SWIG_arg_fail(1)) SWIG_fail;
28758 {
28759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(2)) SWIG_fail;
28761 if (arg2 == NULL) {
28762 SWIG_null_ref("wxDataObject");
28763 }
28764 if (SWIG_arg_fail(2)) SWIG_fail;
28765 }
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->SetData(*arg2);
28769
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 Py_INCREF(Py_None); resultobj = Py_None;
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj;
28782 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28783 wxDataObject *result;
28784 PyObject * obj0 = 0 ;
28785 char *kwnames[] = {
28786 (char *) "self", NULL
28787 };
28788
28789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28791 if (SWIG_arg_fail(1)) SWIG_fail;
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 result = (wxDataObject *)(arg1)->GetDataObject();
28795
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj;
28808 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28809 wxDragResult arg2 ;
28810 wxCursor *arg3 = 0 ;
28811 PyObject * obj0 = 0 ;
28812 PyObject * obj1 = 0 ;
28813 PyObject * obj2 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self",(char *) "res",(char *) "cursor", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 {
28822 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28823 if (SWIG_arg_fail(2)) SWIG_fail;
28824 }
28825 {
28826 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28827 if (SWIG_arg_fail(3)) SWIG_fail;
28828 if (arg3 == NULL) {
28829 SWIG_null_ref("wxCursor");
28830 }
28831 if (SWIG_arg_fail(3)) SWIG_fail;
28832 }
28833 {
28834 PyThreadState* __tstate = wxPyBeginAllowThreads();
28835 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28836
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 Py_INCREF(Py_None); resultobj = Py_None;
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28848 PyObject *resultobj;
28849 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28850 int arg2 = (int) wxDrag_CopyOnly ;
28851 wxDragResult result;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 char *kwnames[] = {
28855 (char *) "self",(char *) "flags", NULL
28856 };
28857
28858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28860 if (SWIG_arg_fail(1)) SWIG_fail;
28861 if (obj1) {
28862 {
28863 arg2 = (int)(SWIG_As_int(obj1));
28864 if (SWIG_arg_fail(2)) SWIG_fail;
28865 }
28866 }
28867 {
28868 PyThreadState* __tstate = wxPyBeginAllowThreads();
28869 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28870
28871 wxPyEndAllowThreads(__tstate);
28872 if (PyErr_Occurred()) SWIG_fail;
28873 }
28874 resultobj = SWIG_From_int((result));
28875 return resultobj;
28876 fail:
28877 return NULL;
28878 }
28879
28880
28881 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj;
28883 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28884 wxDragResult arg2 ;
28885 bool result;
28886 PyObject * obj0 = 0 ;
28887 PyObject * obj1 = 0 ;
28888 char *kwnames[] = {
28889 (char *) "self",(char *) "effect", NULL
28890 };
28891
28892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28894 if (SWIG_arg_fail(1)) SWIG_fail;
28895 {
28896 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28897 if (SWIG_arg_fail(2)) SWIG_fail;
28898 }
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28902
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 {
28907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28908 }
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28916 PyObject *obj;
28917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28918 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28919 Py_INCREF(obj);
28920 return Py_BuildValue((char *)"");
28921 }
28922 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28923 PyObject *resultobj;
28924 wxDataObject *arg1 = (wxDataObject *) NULL ;
28925 wxPyDropTarget *result;
28926 PyObject * obj0 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "dataObject", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28932 if (obj0) {
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 }
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28939
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj;
28952 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28953 PyObject *arg2 = (PyObject *) 0 ;
28954 PyObject *arg3 = (PyObject *) 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 PyObject * obj2 = 0 ;
28958 char *kwnames[] = {
28959 (char *) "self",(char *) "self",(char *) "_class", NULL
28960 };
28961
28962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28964 if (SWIG_arg_fail(1)) SWIG_fail;
28965 arg2 = obj1;
28966 arg3 = obj2;
28967 {
28968 PyThreadState* __tstate = wxPyBeginAllowThreads();
28969 (arg1)->_setCallbackInfo(arg2,arg3);
28970
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 Py_INCREF(Py_None); resultobj = Py_None;
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj;
28983 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28984 PyObject * obj0 = 0 ;
28985 char *kwnames[] = {
28986 (char *) "self", NULL
28987 };
28988
28989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28991 if (SWIG_arg_fail(1)) SWIG_fail;
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 delete arg1;
28995
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 Py_INCREF(Py_None); resultobj = Py_None;
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj;
29008 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29009 wxDataObject *result;
29010 PyObject * obj0 = 0 ;
29011 char *kwnames[] = {
29012 (char *) "self", NULL
29013 };
29014
29015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29017 if (SWIG_arg_fail(1)) SWIG_fail;
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 result = (wxDataObject *)(arg1)->GetDataObject();
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29035 wxDataObject *arg2 = (wxDataObject *) 0 ;
29036 PyObject * obj0 = 0 ;
29037 PyObject * obj1 = 0 ;
29038 char *kwnames[] = {
29039 (char *) "self",(char *) "dataObject", NULL
29040 };
29041
29042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29044 if (SWIG_arg_fail(1)) SWIG_fail;
29045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29046 if (SWIG_arg_fail(2)) SWIG_fail;
29047 {
29048 PyThreadState* __tstate = wxPyBeginAllowThreads();
29049 (arg1)->SetDataObject(arg2);
29050
29051 wxPyEndAllowThreads(__tstate);
29052 if (PyErr_Occurred()) SWIG_fail;
29053 }
29054 Py_INCREF(Py_None); resultobj = Py_None;
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj;
29063 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29064 int arg2 ;
29065 int arg3 ;
29066 wxDragResult arg4 ;
29067 wxDragResult result;
29068 PyObject * obj0 = 0 ;
29069 PyObject * obj1 = 0 ;
29070 PyObject * obj2 = 0 ;
29071 PyObject * obj3 = 0 ;
29072 char *kwnames[] = {
29073 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29074 };
29075
29076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29078 if (SWIG_arg_fail(1)) SWIG_fail;
29079 {
29080 arg2 = (int)(SWIG_As_int(obj1));
29081 if (SWIG_arg_fail(2)) SWIG_fail;
29082 }
29083 {
29084 arg3 = (int)(SWIG_As_int(obj2));
29085 if (SWIG_arg_fail(3)) SWIG_fail;
29086 }
29087 {
29088 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29089 if (SWIG_arg_fail(4)) SWIG_fail;
29090 }
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29094
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 resultobj = SWIG_From_int((result));
29099 return resultobj;
29100 fail:
29101 return NULL;
29102 }
29103
29104
29105 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29106 PyObject *resultobj;
29107 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29108 int arg2 ;
29109 int arg3 ;
29110 wxDragResult arg4 ;
29111 wxDragResult result;
29112 PyObject * obj0 = 0 ;
29113 PyObject * obj1 = 0 ;
29114 PyObject * obj2 = 0 ;
29115 PyObject * obj3 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29122 if (SWIG_arg_fail(1)) SWIG_fail;
29123 {
29124 arg2 = (int)(SWIG_As_int(obj1));
29125 if (SWIG_arg_fail(2)) SWIG_fail;
29126 }
29127 {
29128 arg3 = (int)(SWIG_As_int(obj2));
29129 if (SWIG_arg_fail(3)) SWIG_fail;
29130 }
29131 {
29132 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29133 if (SWIG_arg_fail(4)) SWIG_fail;
29134 }
29135 {
29136 PyThreadState* __tstate = wxPyBeginAllowThreads();
29137 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29138
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 resultobj = SWIG_From_int((result));
29143 return resultobj;
29144 fail:
29145 return NULL;
29146 }
29147
29148
29149 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29150 PyObject *resultobj;
29151 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29152 PyObject * obj0 = 0 ;
29153 char *kwnames[] = {
29154 (char *) "self", NULL
29155 };
29156
29157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 (arg1)->base_OnLeave();
29163
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 Py_INCREF(Py_None); resultobj = Py_None;
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29175 PyObject *resultobj;
29176 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29177 int arg2 ;
29178 int arg3 ;
29179 bool result;
29180 PyObject * obj0 = 0 ;
29181 PyObject * obj1 = 0 ;
29182 PyObject * obj2 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self",(char *) "x",(char *) "y", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 arg2 = (int)(SWIG_As_int(obj1));
29192 if (SWIG_arg_fail(2)) SWIG_fail;
29193 }
29194 {
29195 arg3 = (int)(SWIG_As_int(obj2));
29196 if (SWIG_arg_fail(3)) SWIG_fail;
29197 }
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj;
29216 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29217 bool result;
29218 PyObject * obj0 = 0 ;
29219 char *kwnames[] = {
29220 (char *) "self", NULL
29221 };
29222
29223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29225 if (SWIG_arg_fail(1)) SWIG_fail;
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 result = (bool)(arg1)->GetData();
29229
29230 wxPyEndAllowThreads(__tstate);
29231 if (PyErr_Occurred()) SWIG_fail;
29232 }
29233 {
29234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29235 }
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29243 PyObject *resultobj;
29244 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29245 wxDragResult arg2 ;
29246 PyObject * obj0 = 0 ;
29247 PyObject * obj1 = 0 ;
29248 char *kwnames[] = {
29249 (char *) "self",(char *) "action", NULL
29250 };
29251
29252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29254 if (SWIG_arg_fail(1)) SWIG_fail;
29255 {
29256 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29257 if (SWIG_arg_fail(2)) SWIG_fail;
29258 }
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 (arg1)->SetDefaultAction((wxDragResult )arg2);
29262
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 Py_INCREF(Py_None); resultobj = Py_None;
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj;
29275 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29276 wxDragResult result;
29277 PyObject * obj0 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = (wxDragResult)(arg1)->GetDefaultAction();
29288
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 resultobj = SWIG_From_int((result));
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29300 PyObject *obj;
29301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29302 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29303 Py_INCREF(obj);
29304 return Py_BuildValue((char *)"");
29305 }
29306 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj;
29308 wxPyTextDropTarget *result;
29309 char *kwnames[] = {
29310 NULL
29311 };
29312
29313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29314 {
29315 PyThreadState* __tstate = wxPyBeginAllowThreads();
29316 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29317
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29329 PyObject *resultobj;
29330 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29331 PyObject *arg2 = (PyObject *) 0 ;
29332 PyObject *arg3 = (PyObject *) 0 ;
29333 PyObject * obj0 = 0 ;
29334 PyObject * obj1 = 0 ;
29335 PyObject * obj2 = 0 ;
29336 char *kwnames[] = {
29337 (char *) "self",(char *) "self",(char *) "_class", NULL
29338 };
29339
29340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29342 if (SWIG_arg_fail(1)) SWIG_fail;
29343 arg2 = obj1;
29344 arg3 = obj2;
29345 {
29346 PyThreadState* __tstate = wxPyBeginAllowThreads();
29347 (arg1)->_setCallbackInfo(arg2,arg3);
29348
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 Py_INCREF(Py_None); resultobj = Py_None;
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj;
29361 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29362 int arg2 ;
29363 int arg3 ;
29364 wxDragResult arg4 ;
29365 wxDragResult result;
29366 PyObject * obj0 = 0 ;
29367 PyObject * obj1 = 0 ;
29368 PyObject * obj2 = 0 ;
29369 PyObject * obj3 = 0 ;
29370 char *kwnames[] = {
29371 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29372 };
29373
29374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29376 if (SWIG_arg_fail(1)) SWIG_fail;
29377 {
29378 arg2 = (int)(SWIG_As_int(obj1));
29379 if (SWIG_arg_fail(2)) SWIG_fail;
29380 }
29381 {
29382 arg3 = (int)(SWIG_As_int(obj2));
29383 if (SWIG_arg_fail(3)) SWIG_fail;
29384 }
29385 {
29386 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29387 if (SWIG_arg_fail(4)) SWIG_fail;
29388 }
29389 {
29390 PyThreadState* __tstate = wxPyBeginAllowThreads();
29391 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29392
29393 wxPyEndAllowThreads(__tstate);
29394 if (PyErr_Occurred()) SWIG_fail;
29395 }
29396 resultobj = SWIG_From_int((result));
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29404 PyObject *resultobj;
29405 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29406 int arg2 ;
29407 int arg3 ;
29408 wxDragResult arg4 ;
29409 wxDragResult result;
29410 PyObject * obj0 = 0 ;
29411 PyObject * obj1 = 0 ;
29412 PyObject * obj2 = 0 ;
29413 PyObject * obj3 = 0 ;
29414 char *kwnames[] = {
29415 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29416 };
29417
29418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29420 if (SWIG_arg_fail(1)) SWIG_fail;
29421 {
29422 arg2 = (int)(SWIG_As_int(obj1));
29423 if (SWIG_arg_fail(2)) SWIG_fail;
29424 }
29425 {
29426 arg3 = (int)(SWIG_As_int(obj2));
29427 if (SWIG_arg_fail(3)) SWIG_fail;
29428 }
29429 {
29430 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29431 if (SWIG_arg_fail(4)) SWIG_fail;
29432 }
29433 {
29434 PyThreadState* __tstate = wxPyBeginAllowThreads();
29435 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29436
29437 wxPyEndAllowThreads(__tstate);
29438 if (PyErr_Occurred()) SWIG_fail;
29439 }
29440 resultobj = SWIG_From_int((result));
29441 return resultobj;
29442 fail:
29443 return NULL;
29444 }
29445
29446
29447 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29448 PyObject *resultobj;
29449 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29450 PyObject * obj0 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 (arg1)->base_OnLeave();
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 Py_INCREF(Py_None); resultobj = Py_None;
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29475 int arg2 ;
29476 int arg3 ;
29477 bool result;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 PyObject * obj2 = 0 ;
29481 char *kwnames[] = {
29482 (char *) "self",(char *) "x",(char *) "y", NULL
29483 };
29484
29485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29487 if (SWIG_arg_fail(1)) SWIG_fail;
29488 {
29489 arg2 = (int)(SWIG_As_int(obj1));
29490 if (SWIG_arg_fail(2)) SWIG_fail;
29491 }
29492 {
29493 arg3 = (int)(SWIG_As_int(obj2));
29494 if (SWIG_arg_fail(3)) SWIG_fail;
29495 }
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29499
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 {
29504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29505 }
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj;
29514 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29515 int arg2 ;
29516 int arg3 ;
29517 wxDragResult arg4 ;
29518 wxDragResult result;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 PyObject * obj2 = 0 ;
29522 PyObject * obj3 = 0 ;
29523 char *kwnames[] = {
29524 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29525 };
29526
29527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29529 if (SWIG_arg_fail(1)) SWIG_fail;
29530 {
29531 arg2 = (int)(SWIG_As_int(obj1));
29532 if (SWIG_arg_fail(2)) SWIG_fail;
29533 }
29534 {
29535 arg3 = (int)(SWIG_As_int(obj2));
29536 if (SWIG_arg_fail(3)) SWIG_fail;
29537 }
29538 {
29539 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29540 if (SWIG_arg_fail(4)) SWIG_fail;
29541 }
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29545
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 resultobj = SWIG_From_int((result));
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29557 PyObject *obj;
29558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29559 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29560 Py_INCREF(obj);
29561 return Py_BuildValue((char *)"");
29562 }
29563 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj;
29565 wxPyFileDropTarget *result;
29566 char *kwnames[] = {
29567 NULL
29568 };
29569
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29586 PyObject *resultobj;
29587 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29588 PyObject *arg2 = (PyObject *) 0 ;
29589 PyObject *arg3 = (PyObject *) 0 ;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 PyObject * obj2 = 0 ;
29593 char *kwnames[] = {
29594 (char *) "self",(char *) "self",(char *) "_class", NULL
29595 };
29596
29597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29599 if (SWIG_arg_fail(1)) SWIG_fail;
29600 arg2 = obj1;
29601 arg3 = obj2;
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 (arg1)->_setCallbackInfo(arg2,arg3);
29605
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 Py_INCREF(Py_None); resultobj = Py_None;
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj;
29618 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29619 int arg2 ;
29620 int arg3 ;
29621 wxDragResult arg4 ;
29622 wxDragResult result;
29623 PyObject * obj0 = 0 ;
29624 PyObject * obj1 = 0 ;
29625 PyObject * obj2 = 0 ;
29626 PyObject * obj3 = 0 ;
29627 char *kwnames[] = {
29628 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29629 };
29630
29631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29633 if (SWIG_arg_fail(1)) SWIG_fail;
29634 {
29635 arg2 = (int)(SWIG_As_int(obj1));
29636 if (SWIG_arg_fail(2)) SWIG_fail;
29637 }
29638 {
29639 arg3 = (int)(SWIG_As_int(obj2));
29640 if (SWIG_arg_fail(3)) SWIG_fail;
29641 }
29642 {
29643 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29644 if (SWIG_arg_fail(4)) SWIG_fail;
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_From_int((result));
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj;
29662 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29663 int arg2 ;
29664 int arg3 ;
29665 wxDragResult arg4 ;
29666 wxDragResult result;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 PyObject * obj2 = 0 ;
29670 PyObject * obj3 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 arg2 = (int)(SWIG_As_int(obj1));
29680 if (SWIG_arg_fail(2)) SWIG_fail;
29681 }
29682 {
29683 arg3 = (int)(SWIG_As_int(obj2));
29684 if (SWIG_arg_fail(3)) SWIG_fail;
29685 }
29686 {
29687 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29688 if (SWIG_arg_fail(4)) SWIG_fail;
29689 }
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29693
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 resultobj = SWIG_From_int((result));
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj;
29706 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29707 PyObject * obj0 = 0 ;
29708 char *kwnames[] = {
29709 (char *) "self", NULL
29710 };
29711
29712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29714 if (SWIG_arg_fail(1)) SWIG_fail;
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 (arg1)->base_OnLeave();
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 Py_INCREF(Py_None); resultobj = Py_None;
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj;
29731 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29732 int arg2 ;
29733 int arg3 ;
29734 bool result;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 PyObject * obj2 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self",(char *) "x",(char *) "y", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 arg2 = (int)(SWIG_As_int(obj1));
29747 if (SWIG_arg_fail(2)) SWIG_fail;
29748 }
29749 {
29750 arg3 = (int)(SWIG_As_int(obj2));
29751 if (SWIG_arg_fail(3)) SWIG_fail;
29752 }
29753 {
29754 PyThreadState* __tstate = wxPyBeginAllowThreads();
29755 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29756
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 {
29761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29762 }
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj;
29771 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29772 int arg2 ;
29773 int arg3 ;
29774 wxDragResult arg4 ;
29775 wxDragResult result;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 PyObject * obj2 = 0 ;
29779 PyObject * obj3 = 0 ;
29780 char *kwnames[] = {
29781 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29782 };
29783
29784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29786 if (SWIG_arg_fail(1)) SWIG_fail;
29787 {
29788 arg2 = (int)(SWIG_As_int(obj1));
29789 if (SWIG_arg_fail(2)) SWIG_fail;
29790 }
29791 {
29792 arg3 = (int)(SWIG_As_int(obj2));
29793 if (SWIG_arg_fail(3)) SWIG_fail;
29794 }
29795 {
29796 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29797 if (SWIG_arg_fail(4)) SWIG_fail;
29798 }
29799 {
29800 PyThreadState* __tstate = wxPyBeginAllowThreads();
29801 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29802
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 resultobj = SWIG_From_int((result));
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29814 PyObject *obj;
29815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29816 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29817 Py_INCREF(obj);
29818 return Py_BuildValue((char *)"");
29819 }
29820 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29821 PyObject *resultobj;
29822 wxClipboard *result;
29823 char *kwnames[] = {
29824 NULL
29825 };
29826
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxClipboard *)new wxClipboard();
29831
29832 wxPyEndAllowThreads(__tstate);
29833 if (PyErr_Occurred()) SWIG_fail;
29834 }
29835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29843 PyObject *resultobj;
29844 wxClipboard *arg1 = (wxClipboard *) 0 ;
29845 PyObject * obj0 = 0 ;
29846 char *kwnames[] = {
29847 (char *) "self", NULL
29848 };
29849
29850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29852 if (SWIG_arg_fail(1)) SWIG_fail;
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 delete arg1;
29856
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 Py_INCREF(Py_None); resultobj = Py_None;
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxClipboard *arg1 = (wxClipboard *) 0 ;
29870 bool result;
29871 PyObject * obj0 = 0 ;
29872 char *kwnames[] = {
29873 (char *) "self", NULL
29874 };
29875
29876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(1)) SWIG_fail;
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (bool)(arg1)->Open();
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 {
29887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29888 }
29889 return resultobj;
29890 fail:
29891 return NULL;
29892 }
29893
29894
29895 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29896 PyObject *resultobj;
29897 wxClipboard *arg1 = (wxClipboard *) 0 ;
29898 PyObject * obj0 = 0 ;
29899 char *kwnames[] = {
29900 (char *) "self", NULL
29901 };
29902
29903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29905 if (SWIG_arg_fail(1)) SWIG_fail;
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 (arg1)->Close();
29909
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 Py_INCREF(Py_None); resultobj = Py_None;
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj;
29922 wxClipboard *arg1 = (wxClipboard *) 0 ;
29923 bool result;
29924 PyObject * obj0 = 0 ;
29925 char *kwnames[] = {
29926 (char *) "self", NULL
29927 };
29928
29929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29931 if (SWIG_arg_fail(1)) SWIG_fail;
29932 {
29933 PyThreadState* __tstate = wxPyBeginAllowThreads();
29934 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29935
29936 wxPyEndAllowThreads(__tstate);
29937 if (PyErr_Occurred()) SWIG_fail;
29938 }
29939 {
29940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29941 }
29942 return resultobj;
29943 fail:
29944 return NULL;
29945 }
29946
29947
29948 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29949 PyObject *resultobj;
29950 wxClipboard *arg1 = (wxClipboard *) 0 ;
29951 wxDataObject *arg2 = (wxDataObject *) 0 ;
29952 bool result;
29953 PyObject * obj0 = 0 ;
29954 PyObject * obj1 = 0 ;
29955 char *kwnames[] = {
29956 (char *) "self",(char *) "data", NULL
29957 };
29958
29959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29961 if (SWIG_arg_fail(1)) SWIG_fail;
29962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)(arg1)->AddData(arg2);
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxClipboard *arg1 = (wxClipboard *) 0 ;
29983 wxDataObject *arg2 = (wxDataObject *) 0 ;
29984 bool result;
29985 PyObject * obj0 = 0 ;
29986 PyObject * obj1 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self",(char *) "data", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29995 if (SWIG_arg_fail(2)) SWIG_fail;
29996 {
29997 PyThreadState* __tstate = wxPyBeginAllowThreads();
29998 result = (bool)(arg1)->SetData(arg2);
29999
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 {
30004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30005 }
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxClipboard *arg1 = (wxClipboard *) 0 ;
30015 wxDataFormat *arg2 = 0 ;
30016 bool result;
30017 PyObject * obj0 = 0 ;
30018 PyObject * obj1 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self",(char *) "format", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 {
30027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30028 if (SWIG_arg_fail(2)) SWIG_fail;
30029 if (arg2 == NULL) {
30030 SWIG_null_ref("wxDataFormat");
30031 }
30032 if (SWIG_arg_fail(2)) SWIG_fail;
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (bool)(arg1)->IsSupported((wxDataFormat 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_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj;
30052 wxClipboard *arg1 = (wxClipboard *) 0 ;
30053 wxDataObject *arg2 = 0 ;
30054 bool result;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self",(char *) "data", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 {
30065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(2)) SWIG_fail;
30067 if (arg2 == NULL) {
30068 SWIG_null_ref("wxDataObject");
30069 }
30070 if (SWIG_arg_fail(2)) SWIG_fail;
30071 }
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (bool)(arg1)->GetData(*arg2);
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxClipboard *arg1 = (wxClipboard *) 0 ;
30091 PyObject * obj0 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 (arg1)->Clear();
30102
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 Py_INCREF(Py_None); resultobj = Py_None;
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj;
30115 wxClipboard *arg1 = (wxClipboard *) 0 ;
30116 bool result;
30117 PyObject * obj0 = 0 ;
30118 char *kwnames[] = {
30119 (char *) "self", NULL
30120 };
30121
30122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30124 if (SWIG_arg_fail(1)) SWIG_fail;
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (bool)(arg1)->Flush();
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 {
30133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30134 }
30135 return resultobj;
30136 fail:
30137 return NULL;
30138 }
30139
30140
30141 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30142 PyObject *resultobj;
30143 wxClipboard *arg1 = (wxClipboard *) 0 ;
30144 bool arg2 = (bool) true ;
30145 PyObject * obj0 = 0 ;
30146 PyObject * obj1 = 0 ;
30147 char *kwnames[] = {
30148 (char *) "self",(char *) "primary", NULL
30149 };
30150
30151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30153 if (SWIG_arg_fail(1)) SWIG_fail;
30154 if (obj1) {
30155 {
30156 arg2 = (bool)(SWIG_As_bool(obj1));
30157 if (SWIG_arg_fail(2)) SWIG_fail;
30158 }
30159 }
30160 {
30161 PyThreadState* __tstate = wxPyBeginAllowThreads();
30162 (arg1)->UsePrimarySelection(arg2);
30163
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 Py_INCREF(Py_None); resultobj = Py_None;
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj;
30176 wxClipboard *result;
30177 char *kwnames[] = {
30178 NULL
30179 };
30180
30181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = (wxClipboard *)wxClipboard::Get();
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30197 PyObject *obj;
30198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30199 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30200 Py_INCREF(obj);
30201 return Py_BuildValue((char *)"");
30202 }
30203 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30204 PyObject *resultobj;
30205 wxClipboard *arg1 = (wxClipboard *) NULL ;
30206 wxClipboardLocker *result;
30207 PyObject * obj0 = 0 ;
30208 char *kwnames[] = {
30209 (char *) "clipboard", NULL
30210 };
30211
30212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30213 if (obj0) {
30214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30215 if (SWIG_arg_fail(1)) SWIG_fail;
30216 }
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30220
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj;
30233 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30234 PyObject * obj0 = 0 ;
30235 char *kwnames[] = {
30236 (char *) "self", NULL
30237 };
30238
30239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30241 if (SWIG_arg_fail(1)) SWIG_fail;
30242 {
30243 PyThreadState* __tstate = wxPyBeginAllowThreads();
30244 delete arg1;
30245
30246 wxPyEndAllowThreads(__tstate);
30247 if (PyErr_Occurred()) SWIG_fail;
30248 }
30249 Py_INCREF(Py_None); resultobj = Py_None;
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj;
30258 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30259 bool result;
30260 PyObject * obj0 = 0 ;
30261 char *kwnames[] = {
30262 (char *) "self", NULL
30263 };
30264
30265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30267 if (SWIG_arg_fail(1)) SWIG_fail;
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 result = (bool)wxClipboardLocker___nonzero__(arg1);
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 {
30276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30277 }
30278 return resultobj;
30279 fail:
30280 return NULL;
30281 }
30282
30283
30284 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30285 PyObject *obj;
30286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30287 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30288 Py_INCREF(obj);
30289 return Py_BuildValue((char *)"");
30290 }
30291 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30292 PyObject *resultobj;
30293 int arg1 = (int) 0 ;
30294 int arg2 = (int) 0 ;
30295 int arg3 = (int) 0 ;
30296 int arg4 = (int) 0 ;
30297 wxVideoMode *result;
30298 PyObject * obj0 = 0 ;
30299 PyObject * obj1 = 0 ;
30300 PyObject * obj2 = 0 ;
30301 PyObject * obj3 = 0 ;
30302 char *kwnames[] = {
30303 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30304 };
30305
30306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30307 if (obj0) {
30308 {
30309 arg1 = (int)(SWIG_As_int(obj0));
30310 if (SWIG_arg_fail(1)) SWIG_fail;
30311 }
30312 }
30313 if (obj1) {
30314 {
30315 arg2 = (int)(SWIG_As_int(obj1));
30316 if (SWIG_arg_fail(2)) SWIG_fail;
30317 }
30318 }
30319 if (obj2) {
30320 {
30321 arg3 = (int)(SWIG_As_int(obj2));
30322 if (SWIG_arg_fail(3)) SWIG_fail;
30323 }
30324 }
30325 if (obj3) {
30326 {
30327 arg4 = (int)(SWIG_As_int(obj3));
30328 if (SWIG_arg_fail(4)) SWIG_fail;
30329 }
30330 }
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30334
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30339 return resultobj;
30340 fail:
30341 return NULL;
30342 }
30343
30344
30345 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30346 PyObject *resultobj;
30347 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30348 PyObject * obj0 = 0 ;
30349 char *kwnames[] = {
30350 (char *) "self", NULL
30351 };
30352
30353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30355 if (SWIG_arg_fail(1)) SWIG_fail;
30356 {
30357 PyThreadState* __tstate = wxPyBeginAllowThreads();
30358 delete arg1;
30359
30360 wxPyEndAllowThreads(__tstate);
30361 if (PyErr_Occurred()) SWIG_fail;
30362 }
30363 Py_INCREF(Py_None); resultobj = Py_None;
30364 return resultobj;
30365 fail:
30366 return NULL;
30367 }
30368
30369
30370 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30371 PyObject *resultobj;
30372 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30373 wxVideoMode *arg2 = 0 ;
30374 bool result;
30375 PyObject * obj0 = 0 ;
30376 PyObject * obj1 = 0 ;
30377 char *kwnames[] = {
30378 (char *) "self",(char *) "other", NULL
30379 };
30380
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 {
30385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30386 if (SWIG_arg_fail(2)) SWIG_fail;
30387 if (arg2 == NULL) {
30388 SWIG_null_ref("wxVideoMode");
30389 }
30390 if (SWIG_arg_fail(2)) SWIG_fail;
30391 }
30392 {
30393 PyThreadState* __tstate = wxPyBeginAllowThreads();
30394 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30395
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 {
30400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30401 }
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30409 PyObject *resultobj;
30410 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30411 int result;
30412 PyObject * obj0 = 0 ;
30413 char *kwnames[] = {
30414 (char *) "self", NULL
30415 };
30416
30417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30419 if (SWIG_arg_fail(1)) SWIG_fail;
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30423
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 {
30428 resultobj = SWIG_From_int((int)(result));
30429 }
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj;
30438 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30439 int result;
30440 PyObject * obj0 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "self", NULL
30443 };
30444
30445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30447 if (SWIG_arg_fail(1)) SWIG_fail;
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30451
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 {
30456 resultobj = SWIG_From_int((int)(result));
30457 }
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30465 PyObject *resultobj;
30466 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30467 int result;
30468 PyObject * obj0 = 0 ;
30469 char *kwnames[] = {
30470 (char *) "self", NULL
30471 };
30472
30473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30475 if (SWIG_arg_fail(1)) SWIG_fail;
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 resultobj = SWIG_From_int((int)(result));
30485 }
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj;
30494 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30495 bool result;
30496 PyObject * obj0 = 0 ;
30497 char *kwnames[] = {
30498 (char *) "self", NULL
30499 };
30500
30501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30503 if (SWIG_arg_fail(1)) SWIG_fail;
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj;
30522 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30523 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30524 bool result;
30525 PyObject * obj0 = 0 ;
30526 PyObject * obj1 = 0 ;
30527 char *kwnames[] = {
30528 (char *) "self",(char *) "other", NULL
30529 };
30530
30531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30533 if (SWIG_arg_fail(1)) SWIG_fail;
30534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(2)) SWIG_fail;
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30555 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30556 bool result;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 char *kwnames[] = {
30560 (char *) "self",(char *) "other", NULL
30561 };
30562
30563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30565 if (SWIG_arg_fail(1)) SWIG_fail;
30566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(2)) SWIG_fail;
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30571
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 {
30576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30577 }
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj;
30586 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30587 int arg2 ;
30588 PyObject * obj0 = 0 ;
30589 PyObject * obj1 = 0 ;
30590 char *kwnames[] = {
30591 (char *) "self",(char *) "w", NULL
30592 };
30593
30594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30596 if (SWIG_arg_fail(1)) SWIG_fail;
30597 {
30598 arg2 = (int)(SWIG_As_int(obj1));
30599 if (SWIG_arg_fail(2)) SWIG_fail;
30600 }
30601 if (arg1) (arg1)->w = arg2;
30602
30603 Py_INCREF(Py_None); resultobj = Py_None;
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj;
30612 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30613 int result;
30614 PyObject * obj0 = 0 ;
30615 char *kwnames[] = {
30616 (char *) "self", NULL
30617 };
30618
30619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30621 if (SWIG_arg_fail(1)) SWIG_fail;
30622 result = (int) ((arg1)->w);
30623
30624 {
30625 resultobj = SWIG_From_int((int)(result));
30626 }
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj;
30635 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30636 int arg2 ;
30637 PyObject * obj0 = 0 ;
30638 PyObject * obj1 = 0 ;
30639 char *kwnames[] = {
30640 (char *) "self",(char *) "h", NULL
30641 };
30642
30643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30645 if (SWIG_arg_fail(1)) SWIG_fail;
30646 {
30647 arg2 = (int)(SWIG_As_int(obj1));
30648 if (SWIG_arg_fail(2)) SWIG_fail;
30649 }
30650 if (arg1) (arg1)->h = arg2;
30651
30652 Py_INCREF(Py_None); resultobj = Py_None;
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj;
30661 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30662 int result;
30663 PyObject * obj0 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 result = (int) ((arg1)->h);
30672
30673 {
30674 resultobj = SWIG_From_int((int)(result));
30675 }
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj;
30684 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30685 int arg2 ;
30686 PyObject * obj0 = 0 ;
30687 PyObject * obj1 = 0 ;
30688 char *kwnames[] = {
30689 (char *) "self",(char *) "bpp", NULL
30690 };
30691
30692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30694 if (SWIG_arg_fail(1)) SWIG_fail;
30695 {
30696 arg2 = (int)(SWIG_As_int(obj1));
30697 if (SWIG_arg_fail(2)) SWIG_fail;
30698 }
30699 if (arg1) (arg1)->bpp = arg2;
30700
30701 Py_INCREF(Py_None); resultobj = Py_None;
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj;
30710 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30711 int result;
30712 PyObject * obj0 = 0 ;
30713 char *kwnames[] = {
30714 (char *) "self", NULL
30715 };
30716
30717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30719 if (SWIG_arg_fail(1)) SWIG_fail;
30720 result = (int) ((arg1)->bpp);
30721
30722 {
30723 resultobj = SWIG_From_int((int)(result));
30724 }
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30732 PyObject *resultobj;
30733 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30734 int arg2 ;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 char *kwnames[] = {
30738 (char *) "self",(char *) "refresh", NULL
30739 };
30740
30741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30743 if (SWIG_arg_fail(1)) SWIG_fail;
30744 {
30745 arg2 = (int)(SWIG_As_int(obj1));
30746 if (SWIG_arg_fail(2)) SWIG_fail;
30747 }
30748 if (arg1) (arg1)->refresh = arg2;
30749
30750 Py_INCREF(Py_None); resultobj = Py_None;
30751 return resultobj;
30752 fail:
30753 return NULL;
30754 }
30755
30756
30757 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30758 PyObject *resultobj;
30759 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30760 int result;
30761 PyObject * obj0 = 0 ;
30762 char *kwnames[] = {
30763 (char *) "self", NULL
30764 };
30765
30766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30768 if (SWIG_arg_fail(1)) SWIG_fail;
30769 result = (int) ((arg1)->refresh);
30770
30771 {
30772 resultobj = SWIG_From_int((int)(result));
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30781 PyObject *obj;
30782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30783 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30784 Py_INCREF(obj);
30785 return Py_BuildValue((char *)"");
30786 }
30787 static int _wrap_DefaultVideoMode_set(PyObject *) {
30788 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30789 return 1;
30790 }
30791
30792
30793 static PyObject *_wrap_DefaultVideoMode_get(void) {
30794 PyObject *pyobj;
30795
30796 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30797 return pyobj;
30798 }
30799
30800
30801 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj;
30803 size_t arg1 = (size_t) 0 ;
30804 wxDisplay *result;
30805 PyObject * obj0 = 0 ;
30806 char *kwnames[] = {
30807 (char *) "index", NULL
30808 };
30809
30810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30811 if (obj0) {
30812 {
30813 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 }
30816 }
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 result = (wxDisplay *)new wxDisplay(arg1);
30820
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj;
30833 wxDisplay *arg1 = (wxDisplay *) 0 ;
30834 PyObject * obj0 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "self", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30841 if (SWIG_arg_fail(1)) SWIG_fail;
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 delete arg1;
30845
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 Py_INCREF(Py_None); resultobj = Py_None;
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj;
30858 size_t result;
30859 char *kwnames[] = {
30860 NULL
30861 };
30862
30863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = (size_t)wxDisplay::GetCount();
30867
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 {
30872 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30873 }
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30881 PyObject *resultobj;
30882 wxPoint *arg1 = 0 ;
30883 int result;
30884 wxPoint temp1 ;
30885 PyObject * obj0 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "pt", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30891 {
30892 arg1 = &temp1;
30893 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30894 }
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30898
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 {
30903 resultobj = SWIG_From_int((int)(result));
30904 }
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 int result;
30915 PyObject * obj0 = 0 ;
30916 char *kwnames[] = {
30917 (char *) "window", NULL
30918 };
30919
30920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30922 if (SWIG_arg_fail(1)) SWIG_fail;
30923 {
30924 PyThreadState* __tstate = wxPyBeginAllowThreads();
30925 result = (int)Display_GetFromWindow(arg1);
30926
30927 wxPyEndAllowThreads(__tstate);
30928 if (PyErr_Occurred()) SWIG_fail;
30929 }
30930 {
30931 resultobj = SWIG_From_int((int)(result));
30932 }
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30940 PyObject *resultobj;
30941 wxDisplay *arg1 = (wxDisplay *) 0 ;
30942 bool result;
30943 PyObject * obj0 = 0 ;
30944 char *kwnames[] = {
30945 (char *) "self", NULL
30946 };
30947
30948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30950 if (SWIG_arg_fail(1)) SWIG_fail;
30951 {
30952 PyThreadState* __tstate = wxPyBeginAllowThreads();
30953 result = (bool)((wxDisplay const *)arg1)->IsOk();
30954
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 {
30959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30960 }
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30968 PyObject *resultobj;
30969 wxDisplay *arg1 = (wxDisplay *) 0 ;
30970 wxRect result;
30971 PyObject * obj0 = 0 ;
30972 char *kwnames[] = {
30973 (char *) "self", NULL
30974 };
30975
30976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(1)) SWIG_fail;
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 result = ((wxDisplay const *)arg1)->GetGeometry();
30982
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 {
30987 wxRect * resultptr;
30988 resultptr = new wxRect((wxRect &)(result));
30989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30998 PyObject *resultobj;
30999 wxDisplay *arg1 = (wxDisplay *) 0 ;
31000 wxString result;
31001 PyObject * obj0 = 0 ;
31002 char *kwnames[] = {
31003 (char *) "self", NULL
31004 };
31005
31006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31008 if (SWIG_arg_fail(1)) SWIG_fail;
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = ((wxDisplay const *)arg1)->GetName();
31012
31013 wxPyEndAllowThreads(__tstate);
31014 if (PyErr_Occurred()) SWIG_fail;
31015 }
31016 {
31017 #if wxUSE_UNICODE
31018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31019 #else
31020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31021 #endif
31022 }
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31030 PyObject *resultobj;
31031 wxDisplay *arg1 = (wxDisplay *) 0 ;
31032 bool result;
31033 PyObject * obj0 = 0 ;
31034 char *kwnames[] = {
31035 (char *) "self", NULL
31036 };
31037
31038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31040 if (SWIG_arg_fail(1)) SWIG_fail;
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31044
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 {
31049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31050 }
31051 return resultobj;
31052 fail:
31053 return NULL;
31054 }
31055
31056
31057 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31058 PyObject *resultobj;
31059 wxDisplay *arg1 = (wxDisplay *) 0 ;
31060 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31061 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31062 PyObject *result;
31063 PyObject * obj0 = 0 ;
31064 PyObject * obj1 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self",(char *) "mode", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 if (obj1) {
31073 {
31074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31075 if (SWIG_arg_fail(2)) SWIG_fail;
31076 if (arg2 == NULL) {
31077 SWIG_null_ref("wxVideoMode");
31078 }
31079 if (SWIG_arg_fail(2)) SWIG_fail;
31080 }
31081 }
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31085
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 resultobj = result;
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj;
31098 wxDisplay *arg1 = (wxDisplay *) 0 ;
31099 wxVideoMode result;
31100 PyObject * obj0 = 0 ;
31101 char *kwnames[] = {
31102 (char *) "self", NULL
31103 };
31104
31105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31107 if (SWIG_arg_fail(1)) SWIG_fail;
31108 {
31109 PyThreadState* __tstate = wxPyBeginAllowThreads();
31110 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31111
31112 wxPyEndAllowThreads(__tstate);
31113 if (PyErr_Occurred()) SWIG_fail;
31114 }
31115 {
31116 wxVideoMode * resultptr;
31117 resultptr = new wxVideoMode((wxVideoMode &)(result));
31118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31119 }
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxDisplay *arg1 = (wxDisplay *) 0 ;
31129 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31130 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31131 bool result;
31132 PyObject * obj0 = 0 ;
31133 PyObject * obj1 = 0 ;
31134 char *kwnames[] = {
31135 (char *) "self",(char *) "mode", NULL
31136 };
31137
31138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31140 if (SWIG_arg_fail(1)) SWIG_fail;
31141 if (obj1) {
31142 {
31143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31144 if (SWIG_arg_fail(2)) SWIG_fail;
31145 if (arg2 == NULL) {
31146 SWIG_null_ref("wxVideoMode");
31147 }
31148 if (SWIG_arg_fail(2)) SWIG_fail;
31149 }
31150 }
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31154
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 {
31159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31160 }
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31168 PyObject *resultobj;
31169 wxDisplay *arg1 = (wxDisplay *) 0 ;
31170 PyObject * obj0 = 0 ;
31171 char *kwnames[] = {
31172 (char *) "self", NULL
31173 };
31174
31175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31177 if (SWIG_arg_fail(1)) SWIG_fail;
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 (arg1)->ResetMode();
31181
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 Py_INCREF(Py_None); resultobj = Py_None;
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31193 PyObject *obj;
31194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31195 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31196 Py_INCREF(obj);
31197 return Py_BuildValue((char *)"");
31198 }
31199 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31200 PyObject *resultobj;
31201 wxStandardPaths *result;
31202 char *kwnames[] = {
31203 NULL
31204 };
31205
31206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31207 {
31208 PyThreadState* __tstate = wxPyBeginAllowThreads();
31209 result = (wxStandardPaths *)StandardPaths_Get();
31210
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj;
31223 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31224 wxString result;
31225 PyObject * obj0 = 0 ;
31226 char *kwnames[] = {
31227 (char *) "self", NULL
31228 };
31229
31230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31232 if (SWIG_arg_fail(1)) SWIG_fail;
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31236
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 {
31241 #if wxUSE_UNICODE
31242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31243 #else
31244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31245 #endif
31246 }
31247 return resultobj;
31248 fail:
31249 return NULL;
31250 }
31251
31252
31253 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31254 PyObject *resultobj;
31255 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31256 wxString result;
31257 PyObject * obj0 = 0 ;
31258 char *kwnames[] = {
31259 (char *) "self", NULL
31260 };
31261
31262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31264 if (SWIG_arg_fail(1)) SWIG_fail;
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31268
31269 wxPyEndAllowThreads(__tstate);
31270 if (PyErr_Occurred()) SWIG_fail;
31271 }
31272 {
31273 #if wxUSE_UNICODE
31274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31275 #else
31276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31277 #endif
31278 }
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj;
31287 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31288 wxString result;
31289 PyObject * obj0 = 0 ;
31290 char *kwnames[] = {
31291 (char *) "self", NULL
31292 };
31293
31294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31296 if (SWIG_arg_fail(1)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31300
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 {
31305 #if wxUSE_UNICODE
31306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31307 #else
31308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31309 #endif
31310 }
31311 return resultobj;
31312 fail:
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31320 wxString result;
31321 PyObject * obj0 = 0 ;
31322 char *kwnames[] = {
31323 (char *) "self", NULL
31324 };
31325
31326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31328 if (SWIG_arg_fail(1)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31332
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 {
31337 #if wxUSE_UNICODE
31338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31339 #else
31340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31341 #endif
31342 }
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj;
31351 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31352 wxString result;
31353 PyObject * obj0 = 0 ;
31354 char *kwnames[] = {
31355 (char *) "self", NULL
31356 };
31357
31358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31360 if (SWIG_arg_fail(1)) SWIG_fail;
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31364
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 {
31369 #if wxUSE_UNICODE
31370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31371 #else
31372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31373 #endif
31374 }
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj;
31383 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31384 wxString result;
31385 PyObject * obj0 = 0 ;
31386 char *kwnames[] = {
31387 (char *) "self", NULL
31388 };
31389
31390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31392 if (SWIG_arg_fail(1)) SWIG_fail;
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31396
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 {
31401 #if wxUSE_UNICODE
31402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31403 #else
31404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31405 #endif
31406 }
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj;
31415 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31416 wxString result;
31417 PyObject * obj0 = 0 ;
31418 char *kwnames[] = {
31419 (char *) "self", NULL
31420 };
31421
31422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31424 if (SWIG_arg_fail(1)) SWIG_fail;
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31428
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 {
31433 #if wxUSE_UNICODE
31434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31435 #else
31436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31437 #endif
31438 }
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj;
31447 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31448 wxString *arg2 = 0 ;
31449 bool temp2 = false ;
31450 PyObject * obj0 = 0 ;
31451 PyObject * obj1 = 0 ;
31452 char *kwnames[] = {
31453 (char *) "self",(char *) "prefix", NULL
31454 };
31455
31456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31458 if (SWIG_arg_fail(1)) SWIG_fail;
31459 {
31460 arg2 = wxString_in_helper(obj1);
31461 if (arg2 == NULL) SWIG_fail;
31462 temp2 = true;
31463 }
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31467
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 Py_INCREF(Py_None); resultobj = Py_None;
31472 {
31473 if (temp2)
31474 delete arg2;
31475 }
31476 return resultobj;
31477 fail:
31478 {
31479 if (temp2)
31480 delete arg2;
31481 }
31482 return NULL;
31483 }
31484
31485
31486 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31487 PyObject *resultobj;
31488 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31489 wxString result;
31490 PyObject * obj0 = 0 ;
31491 char *kwnames[] = {
31492 (char *) "self", NULL
31493 };
31494
31495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31497 if (SWIG_arg_fail(1)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = wxStandardPaths_GetInstallPrefix(arg1);
31501
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 {
31506 #if wxUSE_UNICODE
31507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31508 #else
31509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31510 #endif
31511 }
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31519 PyObject *obj;
31520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31521 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31522 Py_INCREF(obj);
31523 return Py_BuildValue((char *)"");
31524 }
31525 static PyMethodDef SwigMethods[] = {
31526 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31533 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31541 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31606 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31614 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31632 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31635 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31638 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31641 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31661 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31667 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31676 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31690 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31693 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31694 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31697 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31726 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31728 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31730 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31737 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31743 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31757 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31761 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31764 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31781 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31789 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31836 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31854 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31864 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31880 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31896 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31910 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31920 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31963 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31966 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31969 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31973 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32066 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32067 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32068 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32069 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32086 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32131 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32165 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32173 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32174 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32179 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32188 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32195 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32198 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32201 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32206 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32209 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32213 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32216 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32220 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32221 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32225 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32229 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32233 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32243 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32256 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32264 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32272 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32286 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32290 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32308 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32322 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32333 { NULL, NULL, 0, NULL }
32334 };
32335
32336
32337 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32338
32339 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32340 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32341 }
32342 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32343 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32344 }
32345 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32346 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32347 }
32348 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32349 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32350 }
32351 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32352 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32353 }
32354 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32355 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32356 }
32357 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32358 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32359 }
32360 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32361 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32362 }
32363 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32364 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32365 }
32366 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32367 return (void *)((wxEvent *) ((wxPyEvent *) x));
32368 }
32369 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32370 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32371 }
32372 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32373 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32374 }
32375 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32376 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32377 }
32378 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32379 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32380 }
32381 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32382 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32383 }
32384 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32385 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32386 }
32387 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32388 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32389 }
32390 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32392 }
32393 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32394 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32395 }
32396 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32397 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32398 }
32399 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32400 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32401 }
32402 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32403 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32404 }
32405 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32406 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32407 }
32408 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32409 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32410 }
32411 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32412 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32413 }
32414 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32415 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32416 }
32417 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32418 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32419 }
32420 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32421 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32422 }
32423 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32424 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32425 }
32426 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32427 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32428 }
32429 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32430 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32431 }
32432 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32433 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32434 }
32435 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32436 return (void *)((wxEvent *) ((wxShowEvent *) x));
32437 }
32438 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32439 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32440 }
32441 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32442 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32443 }
32444 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32445 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32446 }
32447 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32448 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32449 }
32450 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32451 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32452 }
32453 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32454 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32455 }
32456 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32457 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32458 }
32459 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32460 return (void *)((wxConfigBase *) ((wxConfig *) x));
32461 }
32462 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32463 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32464 }
32465 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32466 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32467 }
32468 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32469 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32470 }
32471 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32472 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32473 }
32474 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32475 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32476 }
32477 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32478 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32479 }
32480 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32481 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32482 }
32483 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32484 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32485 }
32486 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32487 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32488 }
32489 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32490 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32491 }
32492 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32493 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32494 }
32495 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32496 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32497 }
32498 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32499 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32500 }
32501 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32502 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32503 }
32504 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32505 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32506 }
32507 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32508 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32509 }
32510 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32511 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32512 }
32513 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32514 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32515 }
32516 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32517 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32518 }
32519 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32520 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32521 }
32522 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32523 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32524 }
32525 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32526 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32527 }
32528 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32529 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32530 }
32531 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32532 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32533 }
32534 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32535 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32536 }
32537 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32538 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32539 }
32540 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32541 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32542 }
32543 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32544 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32545 }
32546 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32547 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32548 }
32549 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32550 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32551 }
32552 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32553 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32554 }
32555 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32556 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32557 }
32558 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32559 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32560 }
32561 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32562 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32563 }
32564 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32565 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32566 }
32567 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32568 return (void *)((wxObject *) ((wxSizerItem *) x));
32569 }
32570 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32572 }
32573 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32574 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32575 }
32576 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32577 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32578 }
32579 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32580 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32581 }
32582 static void *_p_wxSizerTo_p_wxObject(void *x) {
32583 return (void *)((wxObject *) ((wxSizer *) x));
32584 }
32585 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32586 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32587 }
32588 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32589 return (void *)((wxObject *) ((wxFileHistory *) x));
32590 }
32591 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32593 }
32594 static void *_p_wxEventTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) ((wxEvent *) x));
32596 }
32597 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32599 }
32600 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32602 }
32603 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32605 }
32606 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32608 }
32609 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32611 }
32612 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32614 }
32615 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32617 }
32618 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32620 }
32621 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32623 }
32624 static void *_p_wxControlTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32626 }
32627 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32629 }
32630 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32632 }
32633 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) ((wxFSFile *) x));
32635 }
32636 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) ((wxClipboard *) x));
32638 }
32639 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32641 }
32642 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32644 }
32645 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32647 }
32648 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32650 }
32651 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) ((wxToolTip *) x));
32653 }
32654 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) ((wxMenuItem *) x));
32656 }
32657 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32659 }
32660 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32662 }
32663 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32665 }
32666 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32668 }
32669 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32671 }
32672 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32674 }
32675 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32677 }
32678 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32680 }
32681 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32683 }
32684 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32686 }
32687 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32689 }
32690 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32692 }
32693 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32695 }
32696 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32698 }
32699 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32701 }
32702 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32704 }
32705 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32707 }
32708 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32710 }
32711 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32713 }
32714 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) ((wxImageHandler *) x));
32716 }
32717 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32719 }
32720 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) ((wxEvtHandler *) x));
32722 }
32723 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32725 }
32726 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32728 }
32729 static void *_p_wxImageTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) ((wxImage *) x));
32731 }
32732 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32734 }
32735 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) ((wxSystemOptions *) x));
32737 }
32738 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32740 }
32741 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32743 }
32744 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32746 }
32747 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32749 }
32750 static void *_p_wxWindowTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32752 }
32753 static void *_p_wxMenuTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32755 }
32756 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32758 }
32759 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32761 }
32762 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) ((wxFileSystem *) x));
32764 }
32765 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32767 }
32768 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32770 }
32771 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32773 }
32774 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32775 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32776 }
32777 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32778 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32779 }
32780 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32781 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32782 }
32783 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32784 return (void *)((wxObject *) ((wxBusyInfo *) x));
32785 }
32786 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32787 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32788 }
32789 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32790 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32791 }
32792 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32793 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32794 }
32795 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32796 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32797 }
32798 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32799 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32800 }
32801 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32802 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32803 }
32804 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32805 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32806 }
32807 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32808 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32809 }
32810 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32811 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32812 }
32813 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32814 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32815 }
32816 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32817 return (void *)((wxLog *) ((wxLogStderr *) x));
32818 }
32819 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32820 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32821 }
32822 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32823 return (void *)((wxLog *) ((wxLogWindow *) x));
32824 }
32825 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32826 return (void *)((wxLog *) ((wxLogChain *) x));
32827 }
32828 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32829 return (void *)((wxLog *) ((wxLogGui *) x));
32830 }
32831 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32832 return (void *)((wxLog *) ((wxPyLog *) x));
32833 }
32834 static void *_p_wxControlTo_p_wxWindow(void *x) {
32835 return (void *)((wxWindow *) ((wxControl *) x));
32836 }
32837 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32838 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32839 }
32840 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32841 return (void *)((wxWindow *) ((wxMenuBar *) x));
32842 }
32843 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32844 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32845 }
32846 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32847 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32848 }
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946
32947 static swig_type_info *swig_types_initial[] = {
32948 _swigt__p_wxLogChain,
32949 _swigt__p_wxMutexGuiLocker,
32950 _swigt__p_wxMetafile,
32951 _swigt__p_wxFileHistory,
32952 _swigt__p_wxLog,
32953 _swigt__p_wxMenu,
32954 _swigt__p_wxEvent,
32955 _swigt__p_wxDateTime__TimeZone,
32956 _swigt__p_wxConfigBase,
32957 _swigt__p_wxDisplay,
32958 _swigt__p_wxFileType,
32959 _swigt__p_wxLogGui,
32960 _swigt__p_wxFont,
32961 _swigt__p_wxDataFormat,
32962 _swigt__p_wxTimerEvent,
32963 _swigt__p_wxCaret,
32964 _swigt__ptrdiff_t,
32965 _swigt__std__ptrdiff_t,
32966 _swigt__p_int,
32967 _swigt__p_wxSize,
32968 _swigt__p_wxClipboard,
32969 _swigt__p_wxStopWatch,
32970 _swigt__p_wxDC,
32971 _swigt__p_wxClipboardLocker,
32972 _swigt__p_wxIcon,
32973 _swigt__p_wxLogStderr,
32974 _swigt__p_wxLogTextCtrl,
32975 _swigt__p_wxTextCtrl,
32976 _swigt__p_wxBusyCursor,
32977 _swigt__p_wxBitmapDataObject,
32978 _swigt__p_wxTextDataObject,
32979 _swigt__p_wxDataObject,
32980 _swigt__p_wxPyTextDataObject,
32981 _swigt__p_wxPyBitmapDataObject,
32982 _swigt__p_wxFileDataObject,
32983 _swigt__p_wxCustomDataObject,
32984 _swigt__p_wxURLDataObject,
32985 _swigt__p_wxMetafileDataObject,
32986 _swigt__p_wxSound,
32987 _swigt__p_wxTimerRunner,
32988 _swigt__p_wxLogWindow,
32989 _swigt__p_wxTimeSpan,
32990 _swigt__p_wxArrayString,
32991 _swigt__p_wxWindowDisabler,
32992 _swigt__p_form_ops_t,
32993 _swigt__p_wxToolTip,
32994 _swigt__p_wxDataObjectComposite,
32995 _swigt__p_wxSystemSettings,
32996 _swigt__p_wxFileConfig,
32997 _swigt__p_wxVideoMode,
32998 _swigt__p_wxDataObjectSimple,
32999 _swigt__p_wxPyDataObjectSimple,
33000 _swigt__p_wxDuplexMode,
33001 _swigt__p_wxEvtHandler,
33002 _swigt__p_wxRect,
33003 _swigt__p_char,
33004 _swigt__p_wxSingleInstanceChecker,
33005 _swigt__p_wxStandardPaths,
33006 _swigt__p_wxFileTypeInfo,
33007 _swigt__p_wxFrame,
33008 _swigt__p_wxTimer,
33009 _swigt__p_wxPaperSize,
33010 _swigt__p_wxMimeTypesManager,
33011 _swigt__p_wxPyArtProvider,
33012 _swigt__p_wxPyTipProvider,
33013 _swigt__p_wxTipProvider,
33014 _swigt__p_wxJoystick,
33015 _swigt__p_wxSystemOptions,
33016 _swigt__p_wxPoint,
33017 _swigt__p_wxJoystickEvent,
33018 _swigt__p_wxCursor,
33019 _swigt__p_wxObject,
33020 _swigt__p_wxOutputStream,
33021 _swigt__p_wxDateTime,
33022 _swigt__p_wxPyDropSource,
33023 _swigt__p_unsigned_long,
33024 _swigt__p_wxKillError,
33025 _swigt__p_wxWindow,
33026 _swigt__p_wxString,
33027 _swigt__p_wxPyProcess,
33028 _swigt__p_wxBitmap,
33029 _swigt__p_wxConfig,
33030 _swigt__unsigned_int,
33031 _swigt__p_unsigned_int,
33032 _swigt__p_unsigned_char,
33033 _swigt__p_wxChar,
33034 _swigt__p_wxBusyInfo,
33035 _swigt__p_wxPyDropTarget,
33036 _swigt__p_wxPyTextDropTarget,
33037 _swigt__p_wxPyFileDropTarget,
33038 _swigt__p_wxProcessEvent,
33039 _swigt__p_wxPyLog,
33040 _swigt__p_wxLogNull,
33041 _swigt__p_wxColour,
33042 _swigt__p_wxPyTimer,
33043 _swigt__p_wxConfigPathChanger,
33044 _swigt__p_wxDateSpan,
33045 0
33046 };
33047
33048
33049 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33050
33051 static swig_const_info swig_const_table[] = {
33052 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33053 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33054 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33055 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33056 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33057 {0, 0, 0, 0.0, 0, 0}};
33058
33059 #ifdef __cplusplus
33060 }
33061 #endif
33062
33063
33064 #ifdef __cplusplus
33065 extern "C" {
33066 #endif
33067
33068 /* Python-specific SWIG API */
33069 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33070 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33071 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33072
33073 /* -----------------------------------------------------------------------------
33074 * global variable support code.
33075 * ----------------------------------------------------------------------------- */
33076
33077 typedef struct swig_globalvar {
33078 char *name; /* Name of global variable */
33079 PyObject *(*get_attr)(); /* Return the current value */
33080 int (*set_attr)(PyObject *); /* Set the value */
33081 struct swig_globalvar *next;
33082 } swig_globalvar;
33083
33084 typedef struct swig_varlinkobject {
33085 PyObject_HEAD
33086 swig_globalvar *vars;
33087 } swig_varlinkobject;
33088
33089 static PyObject *
33090 swig_varlink_repr(swig_varlinkobject *v) {
33091 v = v;
33092 return PyString_FromString("<Swig global variables>");
33093 }
33094
33095 static int
33096 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33097 swig_globalvar *var;
33098 flags = flags;
33099 fprintf(fp,"Swig global variables { ");
33100 for (var = v->vars; var; var=var->next) {
33101 fprintf(fp,"%s", var->name);
33102 if (var->next) fprintf(fp,", ");
33103 }
33104 fprintf(fp," }\n");
33105 return 0;
33106 }
33107
33108 static PyObject *
33109 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33110 swig_globalvar *var = v->vars;
33111 while (var) {
33112 if (strcmp(var->name,n) == 0) {
33113 return (*var->get_attr)();
33114 }
33115 var = var->next;
33116 }
33117 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33118 return NULL;
33119 }
33120
33121 static int
33122 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33123 swig_globalvar *var = v->vars;
33124 while (var) {
33125 if (strcmp(var->name,n) == 0) {
33126 return (*var->set_attr)(p);
33127 }
33128 var = var->next;
33129 }
33130 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33131 return 1;
33132 }
33133
33134 static PyTypeObject varlinktype = {
33135 PyObject_HEAD_INIT(0)
33136 0, /* Number of items in variable part (ob_size) */
33137 (char *)"swigvarlink", /* Type name (tp_name) */
33138 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33139 0, /* Itemsize (tp_itemsize) */
33140 0, /* Deallocator (tp_dealloc) */
33141 (printfunc) swig_varlink_print, /* Print (tp_print) */
33142 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33143 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33144 0, /* tp_compare */
33145 (reprfunc) swig_varlink_repr, /* tp_repr */
33146 0, /* tp_as_number */
33147 0, /* tp_as_sequence */
33148 0, /* tp_as_mapping */
33149 0, /* tp_hash */
33150 0, /* tp_call */
33151 0, /* tp_str */
33152 0, /* tp_getattro */
33153 0, /* tp_setattro */
33154 0, /* tp_as_buffer */
33155 0, /* tp_flags */
33156 0, /* tp_doc */
33157 #if PY_VERSION_HEX >= 0x02000000
33158 0, /* tp_traverse */
33159 0, /* tp_clear */
33160 #endif
33161 #if PY_VERSION_HEX >= 0x02010000
33162 0, /* tp_richcompare */
33163 0, /* tp_weaklistoffset */
33164 #endif
33165 #if PY_VERSION_HEX >= 0x02020000
33166 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33167 #endif
33168 #if PY_VERSION_HEX >= 0x02030000
33169 0, /* tp_del */
33170 #endif
33171 #ifdef COUNT_ALLOCS
33172 0,0,0,0 /* tp_alloc -> tp_next */
33173 #endif
33174 };
33175
33176 /* Create a variable linking object for use later */
33177 static PyObject *
33178 SWIG_Python_newvarlink(void) {
33179 swig_varlinkobject *result = 0;
33180 result = PyMem_NEW(swig_varlinkobject,1);
33181 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33182 result->ob_type = &varlinktype;
33183 result->vars = 0;
33184 result->ob_refcnt = 0;
33185 Py_XINCREF((PyObject *) result);
33186 return ((PyObject*) result);
33187 }
33188
33189 static void
33190 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33191 swig_varlinkobject *v;
33192 swig_globalvar *gv;
33193 v= (swig_varlinkobject *) p;
33194 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33195 gv->name = (char *) malloc(strlen(name)+1);
33196 strcpy(gv->name,name);
33197 gv->get_attr = get_attr;
33198 gv->set_attr = set_attr;
33199 gv->next = v->vars;
33200 v->vars = gv;
33201 }
33202
33203 /* -----------------------------------------------------------------------------
33204 * constants/methods manipulation
33205 * ----------------------------------------------------------------------------- */
33206
33207 /* Install Constants */
33208 static void
33209 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33210 PyObject *obj = 0;
33211 size_t i;
33212 for (i = 0; constants[i].type; i++) {
33213 switch(constants[i].type) {
33214 case SWIG_PY_INT:
33215 obj = PyInt_FromLong(constants[i].lvalue);
33216 break;
33217 case SWIG_PY_FLOAT:
33218 obj = PyFloat_FromDouble(constants[i].dvalue);
33219 break;
33220 case SWIG_PY_STRING:
33221 if (constants[i].pvalue) {
33222 obj = PyString_FromString((char *) constants[i].pvalue);
33223 } else {
33224 Py_INCREF(Py_None);
33225 obj = Py_None;
33226 }
33227 break;
33228 case SWIG_PY_POINTER:
33229 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33230 break;
33231 case SWIG_PY_BINARY:
33232 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33233 break;
33234 default:
33235 obj = 0;
33236 break;
33237 }
33238 if (obj) {
33239 PyDict_SetItemString(d,constants[i].name,obj);
33240 Py_DECREF(obj);
33241 }
33242 }
33243 }
33244
33245 /* -----------------------------------------------------------------------------*/
33246 /* Fix SwigMethods to carry the callback ptrs when needed */
33247 /* -----------------------------------------------------------------------------*/
33248
33249 static void
33250 SWIG_Python_FixMethods(PyMethodDef *methods,
33251 swig_const_info *const_table,
33252 swig_type_info **types,
33253 swig_type_info **types_initial) {
33254 size_t i;
33255 for (i = 0; methods[i].ml_name; ++i) {
33256 char *c = methods[i].ml_doc;
33257 if (c && (c = strstr(c, "swig_ptr: "))) {
33258 int j;
33259 swig_const_info *ci = 0;
33260 char *name = c + 10;
33261 for (j = 0; const_table[j].type; j++) {
33262 if (strncmp(const_table[j].name, name,
33263 strlen(const_table[j].name)) == 0) {
33264 ci = &(const_table[j]);
33265 break;
33266 }
33267 }
33268 if (ci) {
33269 size_t shift = (ci->ptype) - types;
33270 swig_type_info *ty = types_initial[shift];
33271 size_t ldoc = (c - methods[i].ml_doc);
33272 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33273 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33274 char *buff = ndoc;
33275 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33276 strncpy(buff, methods[i].ml_doc, ldoc);
33277 buff += ldoc;
33278 strncpy(buff, "swig_ptr: ", 10);
33279 buff += 10;
33280 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33281 methods[i].ml_doc = ndoc;
33282 }
33283 }
33284 }
33285 }
33286
33287 /* -----------------------------------------------------------------------------*
33288 * Initialize type list
33289 * -----------------------------------------------------------------------------*/
33290
33291 #if PY_MAJOR_VERSION < 2
33292 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33293 is copied out of Python/modsupport.c in python version 2.3.4 */
33294 static int
33295 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33296 {
33297 PyObject *dict;
33298 if (!PyModule_Check(m)) {
33299 PyErr_SetString(PyExc_TypeError,
33300 "PyModule_AddObject() needs module as first arg");
33301 return -1;
33302 }
33303 if (!o) {
33304 PyErr_SetString(PyExc_TypeError,
33305 "PyModule_AddObject() needs non-NULL value");
33306 return -1;
33307 }
33308
33309 dict = PyModule_GetDict(m);
33310 if (dict == NULL) {
33311 /* Internal error -- modules must have a dict! */
33312 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33313 PyModule_GetName(m));
33314 return -1;
33315 }
33316 if (PyDict_SetItemString(dict, name, o))
33317 return -1;
33318 Py_DECREF(o);
33319 return 0;
33320 }
33321 #endif
33322
33323 static swig_type_info **
33324 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33325 static PyMethodDef swig_empty_runtime_method_table[] = {
33326 {
33327 NULL, NULL, 0, NULL
33328 }
33329 };/* Sentinel */
33330
33331 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33332 swig_empty_runtime_method_table);
33333 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33334 if (pointer && module) {
33335 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33336 }
33337 return type_list_handle;
33338 }
33339
33340 static swig_type_info **
33341 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33342 swig_type_info **type_pointer;
33343
33344 /* first check if module already created */
33345 type_pointer = SWIG_Python_GetTypeListHandle();
33346 if (type_pointer) {
33347 return type_pointer;
33348 } else {
33349 /* create a new module and variable */
33350 return SWIG_Python_SetTypeListHandle(type_list_handle);
33351 }
33352 }
33353
33354 #ifdef __cplusplus
33355 }
33356 #endif
33357
33358 /* -----------------------------------------------------------------------------*
33359 * Partial Init method
33360 * -----------------------------------------------------------------------------*/
33361
33362 #ifdef SWIG_LINK_RUNTIME
33363 #ifdef __cplusplus
33364 extern "C"
33365 #endif
33366 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33367 #endif
33368
33369 #ifdef __cplusplus
33370 extern "C"
33371 #endif
33372 SWIGEXPORT(void) SWIG_init(void) {
33373 static PyObject *SWIG_globals = 0;
33374 static int typeinit = 0;
33375 PyObject *m, *d;
33376 int i;
33377 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33378
33379 /* Fix SwigMethods to carry the callback ptrs when needed */
33380 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33381
33382 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33383 d = PyModule_GetDict(m);
33384
33385 if (!typeinit) {
33386 #ifdef SWIG_LINK_RUNTIME
33387 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33388 #else
33389 # ifndef SWIG_STATIC_RUNTIME
33390 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33391 # endif
33392 #endif
33393 for (i = 0; swig_types_initial[i]; i++) {
33394 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33395 }
33396 typeinit = 1;
33397 }
33398 SWIG_InstallConstants(d,swig_const_table);
33399
33400 {
33401 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33672 }
33673 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33674 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33675 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33676 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33677 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33678 {
33679 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33689 }
33690 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33691
33692 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33693
33694 {
33695 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33726 }
33727 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33728 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33729 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33730 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33731 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33732 {
33733 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33824 }
33825 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33826 {
33827 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33840 }
33841
33842 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33843
33844 {
33845 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33864 }
33865 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33866 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33867 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33868 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33869 {
33870 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33892 }
33893 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33908 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33909 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33910 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33911 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33912 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33913 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33914 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33916 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33917 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33918 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33920 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33921 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33922 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33923 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33924 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33925 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33926 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33944 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33945 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33946 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33947 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33949
33950 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33951
33952 {
33953 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33978 }
33979 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33981 {
33982 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34445 }
34446 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34447 {
34448 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34500 }
34501 {
34502 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34503 }
34504 {
34505 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34506 }
34507 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34508 {
34509 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34510 }
34511 {
34512 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34513 }
34514 {
34515 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34516 }
34517 {
34518 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34519 }
34520 {
34521 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34522 }
34523 {
34524 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34525 }
34526 {
34527 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34528 }
34529 {
34530 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34531 }
34532 {
34533 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34534 }
34535 {
34536 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34537 }
34538 {
34539 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34540 }
34541 {
34542 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34543 }
34544
34545 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34546 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34547 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34548 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34549
34550 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34551 }
34552
wxWidgets (Impactor)